scrm-go/controllers/site/site_controller.go

package site

import (
	"github.com/astaxie/beego"
	"SCRM/controllers"
	"fmt"
	"encoding/json"
	"SCRM/utils"
	"SCRM/enums"
	"strconv"
	"SCRM/service/site_service"
	"SCRM/models"
	"time"
	"strings"
	"github.com/jinzhu/gorm"
)



func siteRouters() {
	beego.Router("/api/site/addrotationchart",&Microwebsite{},"Post:AddRotaionChart")
	beego.Router("/api/site/savehispital",&Microwebsite{},"Post:SaveHispital")
	beego.Router("/api/site/addoffices",&Microwebsite{},"Post:AddOffices")
	beego.Router("/api/site/adddoctor",&Microwebsite{},"Post:AddDoctor")
	beego.Router("/api/site/adddoctorinfo",&Microwebsite{},"Post:AddDoctorInfo")
	beego.Router("/api/site/getrationimages",&Microwebsite{},"Get:GetRationImages")
	beego.Router("/api/site/gethospitalinfo",&Microwebsite{},"Get:GetHospitalinfo")
	beego.Router("/api/site/getofficeinfo",&Microwebsite{},"Get:GetOfficeInfo")
	beego.Router("/api/site/keenvironment",&Microwebsite{},"Post:AddKeEnvironment")
	beego.Router("/api/site/getOffEnvironment",&Microwebsite{},"Get:GetOffEnvironment")
	beego.Router("/api/site/addrotationupload",&Microwebsite{},"Post:AddRotationUpload")
	beego.Router("/api/site/addworktime",&Microwebsite{},"Post:AddWorkTime")
	beego.Router("/api/site/addrideway",&Microwebsite{},"Post:AddRideway")
	beego.Router("/api/site/addconnection",&Microwebsite{},"Post:AddConnection")
	beego.Router("/api/site/queryconnetion",&Microwebsite{},"Get:GetQueryConnection")
	beego.Router("/api/site/delete",&Microwebsite{},"Get:DeleteConnecWay")
	beego.Router("/api/site/editconnecway",&Microwebsite{},"Get:EditConnecWay")
	beego.Router("/api/site/saveconnection",&Microwebsite{},"Post:SaveConnection")
	beego.Router("/api/site/addcontract",&Microwebsite{},"Post:AddContract")
	beego.Router("/api/site/getuserdmodel",&Microwebsite{},"Post:GetUserdModel")
	beego.Router("/api/site/eidtmodel",&Microwebsite{},"Get:GetEditModel")
	beego.Router("/api/site/editrideway",&Microwebsite{},"Get:EditRideWay")
	beego.Router("/api/site/saveworktime",&Microwebsite{},"Post:SaveWorktTime")
	beego.Router("/api/site/saverideway",&Microwebsite{},"Post:Saverideway")
	beego.Router("/api/site/getquerynewmodel",&Microwebsite{},"Get:GetQueryNewModel")
	beego.Router("/api/site/getquerydocinfo",&Microwebsite{},"Post:GetQueryDocInfo")
	beego.Router("/api/site/change",&Microwebsite{},"Get:Change")
	beego.Router("/api/site/getquerydochead",&Microwebsite{},"Post:GetQueryDocHead")
	beego.Router("/api/site/deletedoctor",&Microwebsite{},"Get:DeleteDoctor")
	beego.Router("/api/site/edithospital",&Microwebsite{},"Get:EditHospital")
	beego.Router("/api/site/savehostpital",&Microwebsite{},"Post:SaveHospital")
	beego.Router("api/site/editoffice",&Microwebsite{},"Get:EditOffice")
	beego.Router("/api/site/deletemodlebyid",&Microwebsite{},"Get:Deletemodlebyid")
	beego.Router("/api/site/editdoctor",&Microwebsite{},"Get:EditDoctor")
	beego.Router("/api/site/saveoffice",&Microwebsite{},"Post:SaveOffice")
	beego.Router("/api/site/gethospital",&Microwebsite{},"Post:GetHospital")
	beego.Router("/api/site/getDefaultData",&Microwebsite{},"Get:GetDefaultData")
	beego.Router("/api/site/getdata",&Microwebsite{},"Get:GetData")
	beego.Router("/api/site/editdoc",&Microwebsite{},"Get:EditDoc")
	beego.Router("/api/site/savedocinfo",&Microwebsite{},"Post:SaveDocInfo")
	beego.Router("/api/site/editImages",&Microwebsite{},"Get:EditImages")
    beego.Router("/api/site/savedocdata",&Microwebsite{},"Post:Savedocdata")
	beego.Router("/api/site/editofficeenviroment",&Microwebsite{},"Get:EditOfficeEnviroment")
	beego.Router("/api/site/addimages",&Microwebsite{},"Post:AddImages")
	beego.Router("/api/site/saveofficeenvironment",&Microwebsite{},"Post:SaveOfficeEnvironment")
	beego.Router("/api/site/hispitalmore",&Microwebsite{},"Get:Hispitalmore")
    beego.Router("/api/site/officemore",&Microwebsite{},"Get:GetOfficeDetail")
	beego.Router("/api/site/docmore",&Microwebsite{},"Get:GetDoctorDetail")
	beego.Router("/api/site/kemore",&Microwebsite{},"Get:GetOfficEnviromentDetail")
	beego.Router("/api/site/articlemore",&Microwebsite{},"Get:GetArticlistDetail")
	beego.Router("/api/site/activitiesmore",&Microwebsite{},"Get:GetActivitesDetail")
	beego.Router("/api/site/addnavigation",&Microwebsite{},"Post:AddNavigation")
	beego.Router("/api/site/getnavigationlist",&Microwebsite{},"Post:GetNavigationList")
	beego.Router("/api/site/addshareinfo",&Microwebsite{},"Post:AddShareInfo")
	beego.Router("/api/site/getshareinfo",&Microwebsite{},"Post:GetShareInfo")
	beego.Router("/api/site/deletenavition",&Microwebsite{},"Get:DeleteNavition")
	beego.Router("/api/site/deletemodle",&Microwebsite{},"Get:DeleteModle")
	beego.Router("/api/site/getordermodel",&Microwebsite{},"Post:GetOrderModel")
	beego.Router("/api/site/addrotationpic",&Microwebsite{},"Post:AddRotationpic")
	beego.Router("/api/site/getrotationimages",&Microwebsite{},"Post:GetRotationimages")
	beego.Router("/api/site/addrotationimage",&Microwebsite{},"Post:AddrotationImage")
	beego.Router("/api/site/addimageslink",&Microwebsite{},"Post:AddImageslink")
	beego.Router("/api/site/geteditimages",&Microwebsite{},"Post:GetEditImages")
	beego.Router("/api/site/addmagicnavi",&Microwebsite{},"Post:AddMagicNavi")
	beego.Router("/api/site/getmagicimages",&Microwebsite{},"Post:GetMagicImages")
	beego.Router("/api/site/addmarginchart",&Microwebsite{},"Post:AddMarginChart")
	beego.Router("/api/site/deleteRotations",&Microwebsite{},"Post:DeleteRotations")
	beego.Router("/api/site/editRotationImages",&Microwebsite{},"Post:EditRotationImages")
	beego.Router("/api/site/updaterotaionimages",&Microwebsite{},"Post:SaveRotationImages")
	beego.Router("/api/site/editnavigation",&Microwebsite{},"Post:EditNavigation")
	beego.Router("/api/site/savenavigation",&Microwebsite{},"Post:SaveNavigation")
	beego.Router("/api/site/addhospital",&Microwebsite{},"Post:AddHospital")
	beego.Router("/api/site/deletimages",&Microwebsite{},"Post:DeleteImages")
	beego.Router("/api/site/addactive",&Microwebsite{},"Post:AddActive")
	beego.Router("/api/site/getactivity",&Microwebsite{},"Get:GetActivity")
	beego.Router("/api/site/saveactivit",&Microwebsite{},"Post:Saveactivit")
	beego.Router("api/site/deleMargin",&Microwebsite{},"Post:DeleteMargin")
	beego.Router("/api/site/editRotationImages",&Microwebsite{},"Get:GetRotationImages")
	beego.Router("/api/site/getrotationdetail",&Microwebsite{},"Get:GetRotationDetail")
	beego.Router("/api/site/editvisiblebyid",&Microwebsite{},"Get:EditVisibleById")
	beego.Router("/api/site/saveditpic",&Microwebsite{},"Post:SaveEditpic")
	beego.Router("/api/site/addeditpic",&Microwebsite{},"Post:AddEditpic")
	beego.Router("/api/site/addedialogvisible",&Microwebsite{},"Post:AddEdialogVisible")
	beego.Router("/api/site/geteditrotationimages",&Microwebsite{},"Get:GetEditRotationimages")
	beego.Router("/api/site/editsinglevisible",&Microwebsite{},"Get:GetEditSingleVisible")
	beego.Router("/api/site/updatesingleform",&Microwebsite{},"Post:UpdateSingleForm")
	beego.Router("/api/site/addeditpicform",&Microwebsite{},"Post:AddEditPicForm")
	beego.Router("/api/site/addrotationvisible",&Microwebsite{},"Post:AddRotationVisible")
	beego.Router("/api/site/geteditimagesdetail",&Microwebsite{},"Get:GetEditImagesDetail")
	beego.Router("/api/site/updateeditmacgin",&Microwebsite{},"Post:UpdateEditMacgin")
	beego.Router("/api/site/getactivities",&Microwebsite{},"Post:GetActivities")
	beego.Router("/api/site/getArticleType",&Microwebsite{},"Post:GetArticleType")
	beego.Router("/api/site/addarticelist",&Microwebsite{},"Post:AddArticelist")
	beego.Router("/api/site/getarticlelist",&Microwebsite{},"Post:GetArticlelist")
    beego.Router("/api/site/editgetarticlistdetail",&Microwebsite{},"Get:EditGetArticlistDetail")
    beego.Router("/api/site/updatearticedetail",&Microwebsite{},"Post:SaveArticeDetail")
	beego.Router("/api/site/getMacImages",&Microwebsite{},"Get:GetMacImages")
	beego.Router("/api/site/deletesingleimages",&Microwebsite{},"Post:DeleteSingleImages")
	beego.Router("/api/site/getenimages",&Microwebsite{},"Post:GetEnImages")
	beego.Router("/api/site/editenvirimages",&Microwebsite{},"Get:GetEditEnvirimages")
	beego.Router("/api/site/addtwoimages",&Microwebsite{},"Post:AddTwoImages")
	beego.Router("/api/site/addoffficethree",&Microwebsite{},"Post:AddOfficeThree")
	beego.Router("/api/site/offcietwovisible",&Microwebsite{},"Get:GetOfficeTwoVisible")
	beego.Router("/api/site/addofficetwo",&Microwebsite{},"Post:AddOfficeTwo")
	beego.Router("/api/site/deleteofficebyid",&Microwebsite{},"Post:DeleteOfficeById")
	beego.Router("/api/site/getarticlebyid",&Microwebsite{},"Get:GetArticleById")
	beego.Router("/api/site/getallactivity",&Microwebsite{},"Get:GetAllActivity")
	beego.Router("/api/site/addlinkaddresstwo",&Microwebsite{},"Post:AddData")
	beego.Router("/api/site/getlinkaddress",&Microwebsite{},"Get:Getlinkaddress")
	beego.Router("/api/site/getallconnecway",&Microwebsite{},"Get:GetAllConnecway")
	beego.Router("/api/site/getconnecway",&Microwebsite{},"Get:GetConnecway")
	beego.Router("/api/site/editconnecway",&Microwebsite{},"Get:GetConnecwayById")
	beego.Router("/api/site/updateconnectform",&Microwebsite{},"Post:UpdateConnectway")
	beego.Router("/api/site/updatecontactform",&Microwebsite{},"Post:UpdateContact")
	beego.Router("/api/site/addconnectways",&Microwebsite{},"Post:AddConnectways")
	beego.Router("/api/site/gethostpitalintroduction",&Microwebsite{},"Get:GetHostpitalIntroduction")
	beego.Router("/api/site/updatehospitaladdress",&Microwebsite{},"Post:UpdateHospitalAddress")
	beego.Router("/api/site/addpiclink",&Microwebsite{},"Post:AddPicLinkAddress")
	beego.Router("/api/site/getlinkaddressdetail",&Microwebsite{},"Get:GetLinkAddressDetail")
	beego.Router("/api/site/updatepicformthree",&Microwebsite{},"Post:UpdatePicFformThree")
	beego.Router("/api/site/getenimagestwo",&Microwebsite{},"Get:GetEnImagesTwo")
	beego.Router("/api/site/getenimagesthree",&Microwebsite{},"Get:GetEnImagesThree")
	beego.Router("/api/site/addmagiclinkdata",&Microwebsite{},"Post:AddMagiclinkData")
	beego.Router("/api/site/getmaclinkaddress",&Microwebsite{},"Get:GetMacLinkAddress")
	beego.Router("/api/site/addmacgicform",&Microwebsite{},"Post:AddMacgicform")
	beego.Router("/api/site/getmacimagesdetail",&Microwebsite{},"Get:GetMacImagesDetail")
	beego.Router("/api/site/deletemaciamgesdetail",&Microwebsite{},"Post:DeleteMacImagesDetail")
	beego.Router("/api/site/updatemacform",&Microwebsite{},"Post:UpdateMacForm")
	beego.Router("/api/site/geteditmacimagedetail",&Microwebsite{},"Get:GetEditMacImageDetail")
	beego.Router("/api/site/updateeditmacform",&Microwebsite{},"Post:UpdateEditMacForm")
	beego.Router("/api/site/getLikeMacAddressById",&Microwebsite{},"Get:GetLikeMacAddressById")
	beego.Router("/api/site/getarticlename",&Microwebsite{},"Get:GetArticleName")
	beego.Router("/api/site/getallarticelist",&Microwebsite{},"Get:GetAllArticeList")
	beego.Router("/api/site/updatelinkaddress",&Microwebsite{},"Post:UpdateLinkAddress")
	beego.Router("/api/site/addmaclinkaddress",&Microwebsite{},"Post:AddMacLinkAddress")
	beego.Router("/api/site/getlinkaddress",&Microwebsite{},"Get:GetLinkAddress")
	beego.Router("/api/site/getcountimages",&Microwebsite{},"Get:GetCountImages")
    beego.Router("/api/site/addNavigationlinkform",&Microwebsite{},"Post:AddNavigationLinkform")
	beego.Router("/api/site/getnavigationlinkaddress",&Microwebsite{},"Get:GetNavigationlinkaddress")
    beego.Router("/api/site/updateditnavigationlinkform",&Microwebsite{},"Post:UpdateditnavigationLink")
	beego.Router("/api/site/addoctorinfotwo",&Microwebsite{},"Post:AddDoctorInfoTwo")
	beego.Router("/api/site/getuserorgid",&Microwebsite{},"Get:GetUserOrgID")
	beego.Router("/api/site/navigationset",&Microwebsite{},"Get:GetNavigationset")
    beego.Router("/api/site/getnavigationdata",&Microwebsite{},"Get:GetNavigationData")
	beego.Router("/api/site/getallmodeltitle",&Microwebsite{},"Get:GetAllModelTitle")
	beego.Router("/api/site/getdoctordetail",&Microwebsite{},"Get:GetDoctorDetailInfo")
	beego.Router("/api/site/getArticlelistdetail",&Microwebsite{},"Get:GetArticleListDetail")
	beego.Router("/api/site/getActivitieslistinfo",&Microwebsite{},"Get:GetActivitiesListDetail")
	beego.Router("/api/site/addlinkaddressthree",&Microwebsite{},"Post:AddLinkAddressThree")
	beego.Router("/api/getlinkaddressbylinkid",&Microwebsite{},"Get:GetLinkAddressByLinkId")
	beego.Router("/api/site/addlinkaddressfour",&Microwebsite{},"Post:AddLinkAddressFour")
    beego.Router("/api/site/getmaginclinkaddressbyid",&Microwebsite{},"Get:GetMagicLinkAddressById")
	beego.Router("/api.site/getmagicclickbylinkid",&Microwebsite{},"Get:GetMagicClickByLinkID")
	beego.Router("/api/site/editrotationemages",&Microwebsite{},"Get:GeteditRotationEmages")
	beego.Router("/api/site/getoutrotationlink",&Microwebsite{},"Get:GetOutRotationLink")
	beego.Router("/api/site/updatedrolinkaddress",&Microwebsite{},"Post:UpdatedRolinkAddress")
	beego.Router("/api/site/updatedconrotation",&Microwebsite{},"Post:UpdatedConrotation")
	beego.Router("/api/site/getrotationvisiblebylinkid",&Microwebsite{},"Get:GetRotationVisibleByLinkId")
	beego.Router("/api/site/addrotationvisibleform",&Microwebsite{},"Post:AddRotationVisibleForm")
}

type Microwebsite struct {
	controllers.BaseAPIController
}

//轮播图
func (this *Microwebsite) AddRotaionChart()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println("错误是什么呢",err)
	fmt.Println("机构ID",userOrgID)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	title := dataBody["title"].(string)
	if len(title) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "模块标题不能为空")
		return
	}
	fmt.Println("姓名:",title)
	sort := int64(dataBody["sort"].(float64))
	if sort <= 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "排序值不能为空")
		return
	}

	rotationImages := dataBody["rotationImages"]
	//图片数组转为字符串保存到数据库
	images := strings.Replace(strings.Trim(fmt.Sprint(rotationImages), "[]"), " ", ",", -1)
	fmt.Println("姓名:",rotationImages)
	fmt.Println("字符串",images)

	model := models.SgjPatientModel{
		Title:     title,
		Sort:      sort,
		UserOrgId: userOrgID,
		Status:    1,
		Ctime:     time.Now().Unix(),
		ModeType:  1,
	}
	//fmt.Println(model)
     site_service.AddPatientModel(&model)
     fmt.Println("rotation是什么",model)
	patientModel, err := site_service.QueryModel(userOrgID)
	fmt.Println("patientModel是什麽",patientModel)
	idsInters := dataBody["ids"].([]interface{})
	fmt.Println("id集合是",idsInters)
	if len(idsInters) == 0 {
		if err != nil {
			this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "删除会员失败:（没有选择会员）")
			return
		}
	}

	ids := make([]int64, 0)
	for _, idsInter := range idsInters {
		id := int64(idsInter.(float64))
		ids = append(ids, id)
	}
	rotation := models.SgjPatientRotation{
		Title:          title,
		Sort:           sort,
		RotationImages: images,
		UserOrgId:      userOrgID,
		Status:         1,
		Ctime:          time.Now().Unix(),
		ModelId:patientModel.ID,
	}
	editpiclink := models.SgjPatientEditpiclink{
		Modeid: patientModel.ID,
	}
	err = site_service.UpdateEditpicLink(userOrgID, ids, editpiclink)
	fmt.Println("添加错误是设么",err)
	addRotation := site_service.AddRotation(rotation)
	fmt.Println("addRotation",addRotation)
	patientRotation, err := site_service.GetRotationByLastData(userOrgID)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "添加医院失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"rotation":rotation,
		"patientRotation":patientRotation,
	})
}

//医院介绍
func (this *Microwebsite) SaveHispital()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println("错误是什么呢",err)
    fmt.Println("机构ID",userOrgID)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}

	title := dataBody["title"].(string)
	if len(title) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "模块标题不能为空")
		return
	}
	fmt.Println("姓名:",title)
	sort := dataBody["sort"].(string)
	if len(sort) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "排序值不能为空")
		return
	}
	sortt, err := strconv.ParseInt(sort, 10, 64)
	fmt.Println("排序:",sortt)
	introduction := dataBody["introduction"].(string)
	if len(introduction) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "医院介绍不能为空")
		return
	}
	fmt.Println("姓名是什么?",title,"排序是什么",sortt,"医院介绍不能为空",introduction)

	model := models.SgjPatientModel{
		Title:     title,
		Sort:      sortt,
		UserOrgId: userOrgID,
		Ctime:     time.Now().Unix(),
		Status:    1,
		ModeType: 2,
	}

	site_service.AddPatientModel(&model)

	patientModel, err := site_service.QueryModel(userOrgID)

	hospital := models.SgjPatientHospital{
		Title:                title,
		Sort:                 sortt,
		Introduction: introduction,
		UserOrgId:            userOrgID,
		Ctime:                time.Now().Unix(),
		Status:               1,
		Modleid: patientModel.ID,
	}

	err = site_service.AddHispital(hospital)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "添加医院失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"hospital":hospital,
	})
}

//添加科室
func  (this *Microwebsite) AddOffices()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println("错误是什么呢",err)
	fmt.Println("机构ID",userOrgID)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}

	title := dataBody["title"].(string)
	if len(title) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "模块标题不能为空")
		return
	}
	fmt.Println("姓名:",title)
	sort := dataBody["sort"].(string)
	if len(sort) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "排序值不能为空")
		return
	}
	sortt, err := strconv.ParseInt(sort, 10, 64)
	fmt.Println("排序:",sortt)
	introduction := dataBody["introduction"].(string)
	if len(introduction) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "医院介绍不能为空")
		return
	}
	fmt.Println("姓名是什么?",title,"排序是什么",sortt,"医院介绍不能为空",introduction)

	model := models.SgjPatientModel{
		Title:     title,
		Sort:      sortt,
		UserOrgId: userOrgID,
		Ctime:     time.Now().Unix(),
		Status:    1,
		ModeType:   3,
	}

	site_service.AddPatientModel(&model)

	patientModel, err := site_service.QueryModel(userOrgID)

	offices := models.SgjPatientOffices{
		Title:              title,
		Sort:               sortt,
		Introduction: introduction,
		UserOrgId:          userOrgID,
		Ctime:              time.Now().Unix(),
		Status:             1,
		Modleid:patientModel.ID,
	}
	err = site_service.AddOffices(offices)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "添加医院失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"offices":offices,
	})
}

//添加名医
func (this *Microwebsite) AddDoctor()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println("错误是什么呢",err)
	fmt.Println("机构ID",userOrgID)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	title := dataBody["title"].(string)
	if len(title) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "模块标题不能为空")
		return
	}
	fmt.Println("姓名:",title)
	sort := dataBody["sort"].(string)
	if len(sort) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "排序值不能为空")
		return
	}
	sortt, err := strconv.ParseInt(sort, 10, 64)
	fmt.Println("排序:",sortt)

	images := dataBody["docimages"]
	replace := strings.Replace(strings.Trim(fmt.Sprint(images), "[]"), " ", ",", -1)
	//if len(image) == 0 {
	//	this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "医院介绍不能为空")
	//	return
	idsInters := dataBody["ids"].([]interface{})
	fmt.Println("id集合是",idsInters)
	if len(idsInters) == 0 {
		if err != nil {
			this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "删除会员失败:（没有选择会员）")
			return
		}
	}

	ids := make([]int64, 0)
	for _, idsInter := range idsInters {
		id := int64(idsInter.(float64))
		ids = append(ids, id)
	}

	fmt.Println("姓名是什么?",title,"排序是什么",sortt,"图片",replace)
	model := models.SgjPatientModel{
		Title:     title,
		Sort:      sortt,
		UserOrgId: userOrgID,
		Ctime:     time.Now().Unix(),
		Status:    1,
		ModeType:  4,
	}

	site_service.AddPatientModel(&model)
	patientModel, err := site_service.QueryModel(userOrgID)
	fmt.Println("模块ID",patientModel.ID)
	docinfo := models.SgjPatientDocinfo{
		Title:     title,
		Sort:      sortt,
		Docimages: replace,
		UserOrgId: userOrgID,
		Ctime:     time.Now().Unix(),
		Status:    1,
		Modelid:   patientModel.ID,
	}
	err = site_service.AddDoctor(docinfo)
	editdoctor := models.SgjPatientEditdoctor{
		Modleid:patientModel.ID,
	}
	err = site_service.UpdateDoctorsInfo(userOrgID, ids, editdoctor)

	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "添加医院失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"doctor":docinfo,
	})
}

//添加名医介绍
func (this *Microwebsite) AddDoctorInfo()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println("错误是什么呢",err)
	fmt.Println("机构ID",userOrgID)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}

	docname := dataBody["name"].(string)
	if len(docname) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "医生姓名不能为空")
		return
	}
	fmt.Println("医生姓名:",docname)
	docHead := dataBody["dochead"].(string)
	if len(docHead) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "医生头像不能为空")
		return
	}
	fmt.Println("医生头像:",docHead)
	sort := dataBody["sort"].(string)
	if len(sort) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "排序值不能为空")
		return
	}
	sortt, err := strconv.ParseInt(sort, 10, 64)
	fmt.Println("排序:",sortt)
	docpositional := int64(dataBody["user_title"].(float64))
	if docpositional <= 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "医生职位不能为空")
		return
	}
	fmt.Println("医生职位",docpositional)
	docintroduction := dataBody["content"].(string)
	fmt.Println("医生简介",docintroduction)
	if len(docintroduction) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "医生简介不能为空")
		return
	}
	fmt.Println("医生姓名",docname,"医生职位",docpositional,"医生头像",docHead,"医生简介",docintroduction)

	editdoctor := models.SgjPatientEditdoctor{
		DocName:         docname,
		Dochead:         docHead,
		DocPostion:      docpositional,
		Docintroduction: docintroduction,
		Ctime:           time.Now().Unix(),
		UserOrgId:       userOrgID,
		DocSort:         sortt,
		Status:          1,
		ImgShow:       1,
	}
	err = site_service.AddDoctorInfo(editdoctor)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "添加医生失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"doctor":editdoctor,
	})
}

//新增科室环境
func (this *Microwebsite) AddKeEnvironment()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println("错误是什么呢",err)
	fmt.Println("机构ID",userOrgID)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}

	title := dataBody["title"].(string)
	if len(title) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "模块标题不能为空")
		return
	}
	fmt.Println("标题:",title)
	sort := int64(dataBody["sort"].(float64))
	keImages := dataBody["keImages"]
	//图片数组转为字符串保存到数据库
	replace := strings.Replace(strings.Trim(fmt.Sprint(keImages), "[]"), " ", ",", -1)
	fmt.Println("图片:",keImages)
	fmt.Println("字符串",replace)

	idsInters := dataBody["ids"].([]interface{})
	fmt.Println("id集合是",idsInters)
	if len(idsInters) == 0 {
		if err != nil {
			this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "删除会员失败:（没有选择会员）")
			return
		}
	}

	ids := make([]int64, 0)
	for _, idsInter := range idsInters {
		id := int64(idsInter.(float64))
		ids = append(ids, id)
	}
	fmt.Println("ids是什么",ids)
	model := models.SgjPatientModel{
		Title:     title,
		Sort:      sort,
		UserOrgId: userOrgID,
		Ctime:     time.Now().Unix(),
		Status:    1,
		ModeType:   5,
	}

	site_service.AddPatientModel(&model)
	patientModel, err := site_service.QueryModel(userOrgID)

	enviroimages := models.SgjPatientEnviroimages{
		Modeid: patientModel.ID,
	}
	err = site_service.UpdateImages(userOrgID, ids, enviroimages)
    fmt.Println("错误",err)
	officenviroment := models.SgjPatientOffenvironment{
		Title:        title,
		Sort:         sort,
		Keimages: replace,
		Mtime:        time.Now().Unix(),
		UserOrgId:    userOrgID,
		Status:       1,
		Modelid:patientModel.ID,
	}

	err = site_service.AddOffEnvironment(officenviroment)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "添加科室环境失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"offenvironment":officenviroment,
	})
}

//获取轮播图
func (this *Microwebsite) GetRationImages()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	rotation, err := site_service.GetRationImages(userOrgID)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "获取轮播图失败")
		return
	}
	fmt.Println("错误是什么",err)
	fmt.Println("获取的数据",rotation)
	this.ServeSuccessJSON(map[string]interface{}{
		"rotationImages":rotation,
	})
}


//获取医院信息
func (this * Microwebsite) GetHospitalinfo()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	hospital, err := site_service.GetHospitalInfo(userOrgID)
	fmt.Println("数据是什么",hospital)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "获取轮播图失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"hospital":hospital,
	})
}


//获取科室信息
func (this * Microwebsite) GetOfficeInfo()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	offices, err := site_service.GetOfficeInfo(userOrgID)
	fmt.Println("科室介绍数据是什么",offices)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "获取轮播图失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"offices":offices,
	})
}

func (this * Microwebsite) GetQueryDocInfo(){
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	doc, err := site_service.GetQueryDocInfo(userOrgID)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "获取名医介绍失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"doctor":doc,
	})
}

func (this * Microwebsite) GetQueryDocHead()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	docHead, err := site_service.GetQueryDocHead(userOrgID)
	fmt.Println("错误是设么",err)
	fmt.Println("docHead是什么",docHead)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "获取名医介绍失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"docHead":docHead,
	})
}

//获取科室环境
func (this * Microwebsite) GetOffEnvironment()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	offenvironment, err := site_service.GetOffEnvironment(userOrgID)
	fmt.Println("错误是什么",err)
	fmt.Println("科室环境数据",offenvironment)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "获取名医介绍失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"offenvironment":offenvironment,
	})
}

//添加联系我们的轮播图
func  (this * Microwebsite) AddRotationUpload()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println("错误是什么呢",err)
	fmt.Println("机构ID",userOrgID)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}

	title := dataBody["title"].(string)
	if len(title) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "模块标题不能为空")
		return
	}
	fmt.Println("姓名:",title)
	sort := dataBody["sort"].(string)
	if len(sort) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "排序值不能为空")
		return
	}
	sortt, err := strconv.ParseInt(sort, 10, 64)
	fmt.Println("排序:",sortt)
	rotationImages := dataBody["rotationImages"]
	//图片数组转为字符串保存到数据库
	replace := strings.Replace(strings.Trim(fmt.Sprint(rotationImages), "[]"), " ", ",", -1)
	fmt.Println("姓名:",rotationImages)
	fmt.Println("字符串",replace)

	connecmodel := models.SgjPatientConnecmodel{
		Title:          title,
		Sort:           sortt,
		RotationImages: replace,
		UserOrgId:      userOrgID,
		Status:         1,
		ModeType:        1,
		Ctime:          time.Now().Unix(),
	}

	err = site_service.AddRotationUpload(&connecmodel)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "获取名医介绍失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"connecmodel":connecmodel,
	})
}
//添加工作时间
func  (this * Microwebsite) AddWorkTime()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println("错误是什么呢", err)
	fmt.Println("机构ID", userOrgID)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	title := dataBody["title"].(string)
	if len(title) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "模块标题不能为空")
		return
	}
	sort := int64(dataBody["sort"].(float64))
	if sort <= 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "排序值不能为空")
		return
	}

	worktime := dataBody["worktime"].(string)
	if len(worktime) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "工作时间不能为空")
		return
	}

	ordmodel := models.SgjPatientOrdmodel{
		Title:     title,
		Sort:      sort,
		Status:    1,
		UserOrgId: userOrgID,
		ModeType: 4,
		Ctime:     time.Now().Unix(),
	}

	//添加模块
	err = site_service.AddOrdModel(&ordmodel);
	model, err := site_service.QueryOrdeModelByID(userOrgID)

	patientWorktime := models.SgjPatientWorktime{
		Title:     title,
		Sort:      sort,
		Worktime:  worktime,
		UserOrgId: userOrgID,
		Status:    1,
		Ctime:     time.Now().Unix(),
		ModeId: model.ID,
	}

	err = site_service.AddWorkTime(&patientWorktime)

	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "添加乘车方式失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"ordmodel":ordmodel,
		"patientWorktime":patientWorktime,
	})
}

//添加乘车方式
func  (this * Microwebsite) AddRideway() {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println("错误是什么呢", err)
	fmt.Println("机构ID", userOrgID)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}

	title := dataBody["title"].(string)
	if len(title) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "模块标题不能为空")
		return
	}
	fmt.Println("姓名:", title)
	sort :=int64(dataBody["sort"].(float64))
	if sort <= 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "排序值不能为空")
		return
	}
	fmt.Println("排序:", sort)
	content := dataBody["content"].(string)
	if len(content) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "乘车方式不能为空")
		return
	}

	ordemodel := models.SgjPatientOrdmodel{
		Title:         title,
		Sort:          sort,
		UserOrgId:     userOrgID,
		Status:        1,
		ModeType:   5,
		Ctime:         time.Now().Unix(),
	}

	err = site_service.AddOrdModel(&ordemodel)
	model, err := site_service.QueryOrdeModelByID(userOrgID)

	rideway := models.SgjPatientRideway{
		Title:     title,
		Sort:      sort,
		RideWay:   content,
		UserOrgId: userOrgID,
		Status:    1,
		ModeId:    model.ID,
		Ctime:     time.Now().Unix(),
	}

	err = site_service.AddRideWay(rideway)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "添加乘车方式失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"ordemodel":ordemodel,
		"rideway":rideway,
	})

}

//添加联系方式
func (this * Microwebsite) AddConnection()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	fmt.Println("错误是什么呢", err)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	title := dataBody["title"].(string)
	if len(title) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "模块标题不能为空")
		return
	}
	fmt.Println("姓名:", title)
	connecway :=int64( dataBody["connecway"].(float64))
	if connecway < 0{
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "联系方式不能为空")
		return
	}
	fmt.Println("联系方式",connecway)
	content := dataBody["content"].(string)
	if len(content) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "模块标题不能为空")
		return
	}
	fmt.Println("内容",content)

	connection := models.SgjPatientConnection{
		Title:     title,
		Connecway: connecway,
		Content:   content,
		Status:    1,
		Ctime:     time.Now().Unix(),
		UserOrgId:userOrgID,
	}
	err = site_service.AddConnetion(connection);
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "添加联系方式失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"connection":connection,
	})

}

//获取联系方式
func (this * Microwebsite)  GetQueryConnection()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	conection, err := site_service.GetQueryConnection(userOrgID)
	fmt.Println("conections是啥",conection)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "添加乘车方式失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"conection":conection,
	})
}

//删除联系人
func (this * Microwebsite) DeleteConnecWay()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	id, _ := this.GetInt64("id")
	fmt.Println("id是啥?",id)
	err := site_service.DeleteConnecWay(userOrgID, id)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}

	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

//编辑联系人
func (this *Microwebsite) EditConnecWay()  {
	adminUserInfo := this.GetAdminUserInfo()
	id, _ := this.GetInt64("id")
	fmt.Println("id是啥?",id)
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	connection, err := site_service.EditConnecWay(userOrgID, id)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"connection":connection,
	})
}

func (this *Microwebsite) SaveConnection()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println("机构ID",userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("id是啥?",id)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	title := dataBody["title"].(string)
	fmt.Println("title",title)
	if len(title) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "模块标题不能为空")
		return
	}
	connecway := int64(dataBody["connecway"].(float64))
	fmt.Println("connecway",connecway)

	content := dataBody["content"].(string)
	fmt.Println("content",content)
	if len(content) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong,"联系方式不能为空")
		return
	}
	connection := models.SgjPatientConnection{
		Title:     title,
		Connecway: connecway,
		Content:   content,
	}

	site_service.UpadateConnec(&connection,userOrgID,id)

	this.ServeSuccessJSON(map[string]interface{}{
		"connection":connection,
	})

}

//新增联系方式
func (this *Microwebsite) AddContract()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println("机构ID",userOrgID)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	title := dataBody["title"].(string)
	fmt.Println("联系模块标题",title)
	if len(title) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "模块标题不能为空")
		return
	}

	sort := int64(dataBody["sort"].(float64))
	fmt.Println("联系模快排序",sort)
	if sort == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "模块标题不能为空")
		return
	}

	//ids := dataBody["connecWayId"]
	//fmt.Println("联系方式",ids)
	//connecwayId := strings.Replace(strings.Trim(fmt.Sprint(ids), "[]"), " ", ",", -1)
	//tittles := dataBody["conectitle"]
	//tittless := strings.Replace(strings.Trim(fmt.Sprint(tittles), "[]"), " ", ",", -1)
	//fmt.Println("联系名称",tittless)
	//conneccontent := dataBody["conneccontent"]
	//conneccontents := strings.Replace(strings.Trim(fmt.Sprint(conneccontent), "[]"), " ", ",", -1)
	ordmodel := models.SgjPatientOrdmodel{
		Title:     title,
		UserOrgId: userOrgID,
		Sort:      sort,
		Ctime:     time.Now().Unix(),
		ModeType:  3,
		Status:    1,
	}
	err = site_service.AddOrdModel(&ordmodel)
	patientOrdmodel, err := site_service.QueryOrdeModelByID(userOrgID)
	connectway := models.SgjPatientConnectway{
		Title:        title,
		Sort:         sort,
		UserOrgId:    userOrgID,
		Ctime:        time.Now().Unix(),
		Status:       1,
		ModeId: patientOrdmodel.ID,
	}
	err = site_service.AddConnecWay(&connectway)


	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"connectway":connectway,
		"ordmodel":ordmodel,
	})

}

func (this *Microwebsite) GetUserdModel()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	model, err := site_service.GetUserModel(userOrgID)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	fmt.Println("err")
	fmt.Println("模型是什么",model)
	this.ServeSuccessJSON(map[string]interface{}{
		"model":model,
	})
}

func (this *Microwebsite) GetQueryNewModel()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	model, err := site_service.GetQueryNewModel(userOrgID)
	fmt.Println("查询新增模块数据是什么?",model)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	fmt.Println("err")
	fmt.Println("返回新增模块模型是什么",model)
	this.ServeSuccessJSON(map[string]interface{}{
		"model":model,
	})
}

func (this *Microwebsite) GetEditModel()  {
	adminUserInfo := this.GetAdminUserInfo()
	id, _ := this.GetInt64("id")
	fmt.Println("模块id是啥?",id)
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	worktime, err := site_service.GetEditModel(userOrgID, id)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"worktime":worktime,
	})
}

func (this *Microwebsite) EditRideWay()  {
	adminUserInfo := this.GetAdminUserInfo()
	id, _ := this.GetInt64("id")
	fmt.Println("模块id是啥?",id)
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	rideway, err := site_service.GetEditRideWay(userOrgID, id)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"rideway":rideway,
	})
}

//保存编辑后的工作时间
func (this *Microwebsite) SaveWorktTime() {
	adminUserInfo := this.GetAdminUserInfo()
	id, _ := this.GetInt64("id")
	fmt.Println("模块id是啥?",id)
	userOrgID := int64(adminUserInfo.CurrentOrgId)

	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}

	title := dataBody["title"].(string)
	if len(title) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "模块标题不能为空")
		return
	}
	fmt.Println("姓名:", title)
	sort := int64(dataBody["sort"].(float64))
	if sort <= 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "排序值不能为空")
		return
	}
	fmt.Println("排序:", sort)
	worktime := dataBody["worktime"].(string)
	fmt.Println("工作时间",worktime)
	if len(worktime) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "模块标题不能为空")
		return
	}

    modeid := int64(dataBody["mode_id"].(float64))
    fmt.Println("模块ID",modeid)

	ordmodel := models.SgjPatientOrdmodel{
		Title: title,
		Sort:  sort,
	}
	err = site_service.UpdateOrdeModel(modeid, userOrgID,ordmodel)
	patientWorktime := models.SgjPatientWorktime{
		Title:    title,
		Sort:     sort,
		Worktime: worktime,
	}
	err = site_service.UpdateWorkTime(id, userOrgID, patientWorktime)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"patientWorktime":patientWorktime,
	})
}

//保存编辑后的乘车方式
func (this *Microwebsite)  Saverideway()  {
	adminUserInfo := this.GetAdminUserInfo()
	id, _ := this.GetInt64("id")
	fmt.Println("模块id是啥?",id)
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}

	title := dataBody["title"].(string)
	if len(title) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "模块标题不能为空")
		return
	}
	fmt.Println("标题:", title)
	sort := int64(dataBody["sort"].(float64))
	if sort <= 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "排序值不能为空")
		return
	}
	fmt.Println("排序:", sort)
	rideway := dataBody["ride_way"].(string)
	fmt.Println("工作时间",rideway)
	if len(rideway) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "模块标题不能为空")
		return
	}

	modeid:= int64(dataBody["mode_id"].(float64))
	fmt.Println("模块ID",modeid)
	ridewaymodel := models.SgjPatientRideway{
		Title:   title,
		Sort:    sort,
		RideWay: rideway,
	}

	ordmodel := models.SgjPatientOrdmodel{
		Title: title,
		Sort:  sort,
	}

	err = site_service.UpdateRideWay(id, userOrgID, ridewaymodel)
	fmt.Println("错误是设么",err)
	err = site_service.UpdateOrdeModel(modeid, userOrgID, ordmodel)
	fmt.Println("错误是什么?",err)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"ridewaymodel":ridewaymodel,
	})
}

func (this *Microwebsite) Change() {
	adminUserInfo := this.GetAdminUserInfo()
	id, _ := this.GetInt64("id")
	fmt.Println("医生id是啥?",id)
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println("机构id",userOrgID)
	docinfo, err := site_service.QueryDocById(userOrgID, id)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"docinfo":docinfo,
	})
}

func (this *Microwebsite) DeleteDoctor()  {
	adminUserInfo := this.GetAdminUserInfo()
	id, _ := this.GetInt64("id")
	fmt.Println("保存id是啥?",id)
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	err := site_service.DeleteDoctor(id, userOrgID)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除成功")
		return
	}
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *Microwebsite) EditHospital()  {
	adminUserInfo := this.GetAdminUserInfo()
	id, _ := this.GetInt64("id")
	fmt.Println("保存id是啥?",id)
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	hospital, err := site_service.EditHospital(id, userOrgID)
	fmt.Println("参训是什么",hospital)
	fmt.Println(err)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"hospital":hospital,
	})
}

func (this *Microwebsite) SaveHospital()  {
	adminUserInfo := this.GetAdminUserInfo()
	id, _ := this.GetInt64("id")
	fmt.Println("保存id是啥?",id)
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println(userOrgID)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}

	title := dataBody["title"].(string)
	if len(title) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "模块标题不能为空")
		return
	}
	fmt.Println("标题:", title)

	sort := int64(dataBody["sort"].(float64))
	fmt.Println("sort是神",sort)
	if  sort <= 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "排序值不能为空")
		return
	}
	fmt.Println("排序:", sort)
	introduction := dataBody["introduction"].(string)
	if len(introduction) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "模块标题不能为空")
		return
	}

	 modleid := int64(dataBody["modleid"].(float64))
	if  modleid <= 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "模块ID不能为空")
		return
	}
	fmt.Println("模块id",modleid)
	hospital := models.SgjPatientHospital{
		Title:        title,
		Sort:         sort,
		Introduction: introduction,
	}
	err = site_service.UpdateHospital(id, userOrgID, hospital)

	model := models.SgjPatientModel{
		Title:  title,
		Sort:   sort,
	}
	fmt.Println(hospital)
	Modelerr := site_service.UpdateModel(modleid, userOrgID, model)
	fmt.Println("错误是什么",Modelerr)
	fmt.Println("错误是什么",err)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"hospital":hospital,
		"model":model,
	})
}

func (this *Microwebsite) EditOffice()  {
	adminUserInfo := this.GetAdminUserInfo()
	id, _ := this.GetInt64("id")
	fmt.Println("保存id是啥?",id)
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	offices, err := site_service.EditOffice(id, userOrgID)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"offices":offices,
	})
}

func (this *Microwebsite) Deletemodlebyid()  {
	adminUserInfo := this.GetAdminUserInfo()
	id, _ := this.GetInt64("id")
	fmt.Println("保存id是啥?",id)
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	err := site_service.DeletemodleById(id, userOrgID)
	modelid := site_service.DeleteHospitalByModelid(id, userOrgID)
	byModelid := site_service.DeleteOfficeByModelid(id, userOrgID)
	linkByModelid := site_service.DeleteEditPicLinkByModelid(id, userOrgID)
	enviroments := site_service.DeleteEnviroments(id, userOrgID)
	conrotation := site_service.DeleteConrotation(id, userOrgID)
	margin := site_service.DeletePatentEditMargin(id, userOrgID)
	fmt.Println("linkByModelid",linkByModelid)
	fmt.Println("enviroments",enviroments)
	fmt.Println("enviroments",conrotation)
	fmt.Println("margin",margin)
	fmt.Println(modelid,byModelid)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除成功")
		return
	}
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *Microwebsite) SaveOffice()  {
	adminUserInfo := this.GetAdminUserInfo()
	id, _ := this.GetInt64("id")
	fmt.Println("科室介绍id是啥?",id)
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println(userOrgID)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}

	title := dataBody["title"].(string)
	if len(title) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "模块标题不能为空")
		return
	}
	fmt.Println("标题:", title)

	sort := int64(dataBody["sort"].(float64))
	fmt.Println("sort是神",sort)
	if  sort <= 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "排序值不能为空")
		return
	}
	fmt.Println("排序:", sort)
	introduction := dataBody["introduction"].(string)
	fmt.Println("内容",introduction)
	if len(introduction) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "模块标题不能为空")
		return
	}

	modelid := int64(dataBody["modelid"].(float64))
	fmt.Println("模块ID",modelid)
	if  modelid <= 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "模块ID不能为空")
		return
	}

	offices := models.SgjPatientOffices{
		Title:        title,
		Sort:         sort,
		Introduction: introduction,
	}
	updateOffices := site_service.UpdateOffices(id, userOrgID, offices)

	model := models.SgjPatientModel{
		Title: title,
		Sort:  sort,
	}
	updateModel := site_service.UpdateModel(modelid, userOrgID, model)
	fmt.Println(updateModel)
	if updateOffices !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"offices":offices,
		"model":model,
	})
}

func (this *Microwebsite) GetHospital()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)

	hostital, err := site_service.GetHospital(userOrgID)

	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"hostital":hostital,
	})
}



func (this *Microwebsite) GetDefaultData()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("我爱我的机构id",userOrgID)
	model, errcode := site_service.GetModel(userOrgID)
	fmt.Println("model",model)
	fmt.Println("我和我的祖国",errcode)
	if errcode == gorm.ErrRecordNotFound {
		patientModel := models.SgjPatientModel{
			Title:     "轮播图",
			Sort:      1,
			UserOrgId: userOrgID,
			Ctime:     time.Now().Unix(),
			Status:    1,
			ModeType:  1,
		}
		addPatientModel := site_service.AddPatientModelTwo(&patientModel)
		fmt.Println("第一个模块id",addPatientModel)
		sgjPatientModel, err := site_service.GetQueryModelByLastData(userOrgID)
		fmt.Println("查询模块错误是设么",err)
		editpiclink := models.SgjPatientEditpiclink{
			Images:    "https://images.shengws.com/2124_o_1570607834870.png",
			Sort:      1,
			UserOrgId: userOrgID,
			Status:    1,
			Ctime:     time.Now().Unix(),
			Modeid:sgjPatientModel.ID,
		}
		err = site_service.AddPatientEdit(&editpiclink)
		fmt.Println("err",err)

		patientmodefour := models.SgjPatientModel{
			Title:     "魔方导航",
			Sort:      2,
			UserOrgId: userOrgID,
			Ctime:     time.Now().Unix(),
			Status:    1,
			ModeType:  8,
		}
		addPatientModelTwo := site_service.AddPatientModelTwo(&patientmodefour)
		fmt.Println(addPatientModelTwo)
		sgjpatietnmodelfour, err := site_service.GetQueryModelByLastData(userOrgID)
		fmt.Println("第二个模块id",sgjpatietnmodelfour)
		fmt.Println(err)
		editmargin := models.SgjPatientEditmargin{
			Margtitle: "医院介绍",
			Margimage: "https://images.shengws.com/2109_o_1569824063320.png",
			UserOrgId: userOrgID,
			Status:    1,
			Ctime:     time.Now().Unix(),
			Modeid:    sgjpatietnmodelfour.ID,
		}
		margin := site_service.AddEditMargin(&editmargin)
		fmt.Println(margin)

		patientEditmargin := models.SgjPatientEditmargin{
			Margtitle: "医护团队",
			Margimage: "https://images.shengws.com/2121_o_1569824193950.png",
			UserOrgId: userOrgID,
			Status:    1,
			Ctime:     time.Now().Unix(),
			Modeid:    sgjpatietnmodelfour.ID,
		}
		err = site_service.AddEditMargin(&patientEditmargin)
		fmt.Println(err)

		sgjPatientEditmargin := models.SgjPatientEditmargin{
			Margtitle: "科室介绍",
			Margimage: "https://images.shengws.com/2113_o_1569824421007.png",
			UserOrgId: userOrgID,
			Status:    1,
			Ctime:     time.Now().Unix(),
			Modeid:    sgjpatietnmodelfour.ID,
		}

		err = site_service.AddEditMargin(&sgjPatientEditmargin)
		fmt.Println(err)

		patienteditmarginfour := models.SgjPatientEditmargin{
			Margtitle: "医院活动",
			Margimage: "https://images.shengws.com/2131_o_1569824498886.png",
			UserOrgId: userOrgID,
			Status:    1,
			Ctime:     time.Now().Unix(),
			Modeid:    sgjpatietnmodelfour.ID,
		}

		err = site_service.AddEditMargin(&patienteditmarginfour)
		fmt.Println(err)

		patienteditmarginfive := models.SgjPatientEditmargin{
			Margtitle: "医院环境",
			Margimage: "https://images.shengws.com/2148_o_1569824574458.png",
			UserOrgId: userOrgID,
			Status:    1,
			Ctime:     time.Now().Unix(),
			Modeid:    sgjpatietnmodelfour.ID,
		}

		err = site_service.AddEditMargin(&patienteditmarginfive)
		fmt.Println(err)

		patienteditmarginsix := models.SgjPatientEditmargin{
			Margtitle: "咨询服务",
			Margimage: "https://images.shengws.com/2111_o_1569824596227.png",
			UserOrgId: userOrgID,
			Status:    1,
			Ctime:     time.Now().Unix(),
			Modeid:    sgjpatietnmodelfour.ID,
		}
		err = site_service.AddEditMargin(&patienteditmarginsix)
		fmt.Println(err)

		patienteditmarginserven := models.SgjPatientEditmargin{
			Margtitle: "加入会员",
			Margimage: "https://images.shengws.com/2126_o_1569824611892.png",
			UserOrgId: userOrgID,
			Status:    1,
			Ctime:     time.Now().Unix(),
			Modeid:    sgjpatietnmodelfour.ID,
		}

		err = site_service.AddEditMargin(&patienteditmarginserven)
		fmt.Println(err)

		patienteditmargineghit := models.SgjPatientEditmargin{
			Margtitle: "联系我们",
			Margimage: "https://images.shengws.com/2141_o_1569824626531.png",
			UserOrgId: userOrgID,
			Status:    1,
			Ctime:     time.Now().Unix(),
			Modeid:    sgjpatietnmodelfour.ID,
		}
		err = site_service.AddEditMargin(&patienteditmargineghit)
		fmt.Println(err)

		patientModelTwo := models.SgjPatientModel{
			Title:     "医院介绍",
			Sort:      3,
			UserOrgId: userOrgID,
			Ctime:     time.Now().Unix(),
			Status:    1,
			ModeType:  2,
		}
		two := site_service.AddPatientModelTwo(&patientModelTwo)
		fmt.Println(two)
		sgjPatientModelTwo, err := site_service.GetQueryModelByLastData(userOrgID)
		hospital := models.SgjPatientHospital{
			Title:        "医院介绍",
			Sort:         3,
			Introduction: "暂无数据",
			UserOrgId:    userOrgID,
			Modleid:      sgjPatientModelTwo.ID,
			Status:       1,
			Ctime:        time.Now().Unix(),
		}
		addHospital := site_service.AddHospital(&hospital)
		fmt.Println(addHospital)

		Sgjpatientmodelthree := models.SgjPatientModel{
			Title:     "科室介绍",
			Sort:      4,
			UserOrgId: userOrgID,
			Ctime:     time.Now().Unix(),
			Status:    1,
			ModeType:  3,

		}

		modelTwo := site_service.AddPatientModelTwo(&Sgjpatientmodelthree)
		fmt.Println(modelTwo)
		datathree, err := site_service.GetQueryModelByLastData(userOrgID)
		offices := models.SgjPatientOffices{
			Title:     "科室介绍",
			Sort:      4,
			UserOrgId: userOrgID,
			Ctime:     time.Now().Unix(),
			Status:    1,
			Modleid:   datathree.ID,
			Introduction:"暂无数据",
		}
		err = site_service.AddPatientOffices(&offices)
		fmt.Println(err)

		patientModelFive := models.SgjPatientModel{
			Title:     "医护团队",
			Sort:      5,
			UserOrgId: userOrgID,
			Ctime:     time.Now().Unix(),
			Status:    1,
			ModeType:  4,
		}
		err = site_service.AddPatientModelTwo(&patientModelFive)
		fmt.Println("err",err)
		data, err := site_service.GetQueryModelByLastData(userOrgID)
		fmt.Println(err)
		editdoctor := models.SgjPatientEditdoctor{
			Dochead:         "https://images.shengws.com/2062_o_1570608303729.png",
			DocSort:         1,
			Docintroduction: "暂时无数据",
			UserOrgId:       userOrgID,
			Modleid:         data.ID,
			Status:1,
			Ctime:time.Now().Unix(),
			DocPostion:1,
		}
		doctor := site_service.AddEditDoctor(&editdoctor)
		fmt.Println("doctor",doctor)

		modelserven := models.SgjPatientModel{
			Title:     "医院环境",
			Sort:     6,
			UserOrgId: userOrgID,
			Ctime:     time.Now().Unix(),
			Status:    1,
			ModeType:  5,
		}
		err = site_service.AddPatientModelTwo(&modelserven)
		lastData, err := site_service.GetQueryModelByLastData(userOrgID)
		enviroimages := models.SgjPatientEnviroimages{
			Enviroimages: "https://images.shengws.com/2074_o_1570608492452.png",
			Sort:         1,
			UserOrgId:    userOrgID,
			Status:       1,
			Modeid:       lastData.ID,
			Ctime:        time.Now().Unix(),
		}
		err = site_service.AddImages(&enviroimages)
		fmt.Println("err",err)

		//modeleight := models.SgjPatientModel{
		//	Title:     "文章列表",
		//	Sort:      7,
		//	UserOrgId: userOrgID,
		//	Ctime:     time.Now().Unix(),
		//	Status:    1,
		//	ModeType:  6,
		//}
		//err = site_service.AddPatientModelTwo(&modeleight)
		//fmt.Println("文章列表错误u",err)
		//articles := models.Articles{
		//	Title:       "暂无数据",
		//	Imgs:        "https://images.shengws.com/2139_o_1566989829686.jpg",
		//	RealReadNum: 0,
		//	CommentNum:  0,
		//	StarNum:     0,
		//	UserOrgId:userOrgID,
		//	Ctime: time.Now().Unix(),
		//	Status:1,
		//	ArticleStatus:1,
		//}
		//err = site_service.AddActicles(&articles)
		//fmt.Println("err",err)
	}else if  errcode == nil{

	}else {

	}
	if errcode !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"model":model,
	})
}



func (this *Microwebsite) GetData()  {
	fmt.Println("我和我的作古阿斯蒂芬地方地方阿道夫打发阿凡达阿范德萨发撒旦法阿斯蒂芬发送到法阿发法阿发法")
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
    fmt.Println("机构id",userOrgID)
	model, err := site_service.GetData(userOrgID)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"patientModels":model,

	})
}

func (this *Microwebsite) EditDoctor()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println("机构ID" ,userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("编辑名医获取ID",id)
	docinfo, err := site_service.QueryEditDoctor(id, userOrgID)
	fmt.Println(docinfo)
	fmt.Println("错误",err)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"docinfo":docinfo,
	})
}

func  (this *Microwebsite) EditDoctorsInfo()  {
	adminUserInfo := this.GetAdminUserInfo()
	OrgID := adminUserInfo.CurrentOrgId
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	idsInters := dataBody["ids"].([]interface{})
	fmt.Println("id集合是",idsInters)
	if len(idsInters) == 0 {
		if err != nil {
			this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "删除会员失败:（没有选择会员）")
			return
		}
	}

	ids := make([]int64, 0)
	for _, idsInter := range idsInters {
		id := int64(idsInter.(float64))
		ids = append(ids, id)
	}
	patientModel, err := site_service.QueryModel(OrgID)
	fmt.Println("模块ID",patientModel.ID)
	editdoctor := models.SgjPatientEditdoctor{
		Modleid:patientModel.ID,
	}

	err = site_service.UpdateDoctorsInfo(OrgID, ids, editdoctor)
	fmt.Println("更新数据错误",err)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更新数据成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"editdoctor":editdoctor,
	})

}

func (this *Microwebsite) EditDoc()  {
	adminUserInfo := this.GetAdminUserInfo()
	id, _ := this.GetInt64("id")
	fmt.Println("编辑名医id是啥?",id)
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println(userOrgID)
	//editdoctor, err := site_service.QueryEditDoc(id, userOrgID)
	editdoctor, err := site_service.QueryModelByid(id, userOrgID)
	//editdoctors, err := site_service.QuerEditDocByid(id, userOrgID)
	editdoctors, err := site_service.QuerEditDocByModleid(id, userOrgID)
	fmt.Println("错误",err)
	fmt.Println("数据:",editdoctor)
	fmt.Println("数据",editdoctors)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"editdoctor":editdoctor,
		"editdoctors":editdoctors,
	})
}

func  (this *Microwebsite) SaveDocInfo()  {
	adminUserInfo := this.GetAdminUserInfo()
	id, _ := this.GetInt64("id")
	fmt.Println("编辑名医id是啥?",id)
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println(userOrgID)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}

	title := dataBody["doc_name"].(string)
	if len(title) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "模块标题不能为空")
		return
	}
	fmt.Println("医生姓名",title)
	docpostion := int64(dataBody["doc_postion"].(float64))
	fmt.Println("医生职位",docpostion)
	if docpostion <= 0{
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong,"医生职位不能为空")
		return
	}
	dochead := dataBody["dochead"].(string)
	if len(dochead) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "模块标题不能为空")
		return
	}
	fmt.Println("医生头像",dochead)
	docsort :=int64(dataBody["doc_sort"].(float64))
	fmt.Println("排序",docsort)
	docintroduction := dataBody["docintroduction"].(string)
	fmt.Println("医生简介",docintroduction)
	modleid := int64(dataBody["modleid"].(float64))
	fmt.Println("模块idss",modleid)
	editdoctor := models.SgjPatientEditdoctor{
		DocName:         title,
		DocPostion:      docpostion,
		Dochead:         dochead,
		Docintroduction: docintroduction,
		DocSort:docsort,
       ImgShow:1,
       Status:1,
       Ctime:time.Now().Unix(),
	}
	err = site_service.UpDateEditdoctor(id, userOrgID, editdoctor)
	editdoctors, err := site_service.QuerEditDoctorInfo(modleid, userOrgID)
	fmt.Println("错误是",err)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"editdoctor":editdoctor,
		"editdoctors":editdoctors,
	})
}

func (this *Microwebsite) EditImages()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	//fmt.Println("机构ID",userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("路径",id)
	editdoctor, err := site_service.QueryEditImages(userOrgID, id)
	fmt.Println(editdoctor)
	fmt.Println("错误",err)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"editdoctor":editdoctor,
	})
}

func  (this *Microwebsite) Savedocdata()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println("机构ID",userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("路径",id)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}

	title := dataBody["title"].(string)
	if len(title) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "模块标题不能为空")
		return
	}
	fmt.Println("标题",title)
	sort := int64(dataBody["sort"].(float64))
	if sort <= 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "模块标题不能为空")
		return
	}
	fmt.Println("排序",sort)

	image := dataBody["image"]
	replace := strings.Replace(strings.Trim(fmt.Sprint(image), "[]"), " ", ",", -1)
	fmt.Println("图片练级",replace)
	modleid := int64(dataBody["modleid"].(float64))
	if  modleid <= 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "模块ID不能为空")
		return
	}
	fmt.Println("模块ID",modleid)

	docinfo := models.SgjPatientDocinfo{
		Title:     title,
		Sort:      sort,
		Docimages: replace,
		Modelid:modleid,
	}
	err = site_service.Upadatedocdata(userOrgID, id, docinfo)


	model := models.SgjPatientModel{
		Title: title,
		Sort:  sort,
		ID:    modleid,
	}
	err = site_service.UpdateModel(modleid, userOrgID, model)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"docinfo":docinfo,
		"model":model,
	})
}

func (this *Microwebsite) EditOfficeEnviroment()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println("机构ID",userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("科室环境路径",id)
	model, err := site_service.GetQueryModel(id, userOrgID)
	fmt.Println("model错误",err)
	//offenvironment, err := site_service.QuerOfficeEnviroment(id, userOrgID)
	patientenviroimages, err := site_service.QueryOfficeformById(id, userOrgID)
	fmt.Println("错误",err)
	fmt.Println("科室环境数据",patientenviroimages)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"model":model,
		"patientenviroimages":patientenviroimages,
	})
}
func (this *Microwebsite) AddImages()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println("机构ID",userOrgID)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}

	enviroimages := dataBody["enviroimages"].(string)
	fmt.Println("图片",enviroimages)
	if len(enviroimages) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "模块标题不能为空")
		return
	}
	sort := int64(dataBody["sort"].(float64))
	fmt.Println("sort",sort)

	patientEnviroimages := models.SgjPatientEnviroimages{
		Enviroimages: enviroimages,
		Sort:         sort,
		UserOrgId:    userOrgID,
		Ctime:        time.Now().Unix(),
		Status:       1,
		Imgshow:1,

	}
	err = site_service.AddImages(&patientEnviroimages)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"patientEnviroimages":patientEnviroimages,
	})
}


func (this *Microwebsite) SaveOfficeEnvironment()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println("机构ID",userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("科室环境id",id)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}

	title := dataBody["title"].(string)
	if len(title) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "模块标题不能为空")
		return
	}
	fmt.Println("模块标题",title)
	sort := int64(dataBody["sort"].(float64))
	if sort <= 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "模块标题不能为空")
		return
	}
	fmt.Println("排序",sort)
	keimages := dataBody["keImages"]
    fmt.Println("图片",keimages)
	replace := strings.Replace(strings.Trim(fmt.Sprint(keimages), "[]"), " ", ",", -1)
	model := models.SgjPatientModel{
		Title: title,
		Sort:  sort,
	}
	//offenvironment, err := site_service.GetOffENvironmentById(id, userOrgID)
	err = site_service.UpdateModel(id, userOrgID, model)
	fmt.Println("错误",err)
	patientOffenvironment := models.SgjPatientOffenvironment{
		Title:    title,
		Sort:     sort,
		Keimages: replace,
	}
	err = site_service.UpdatePatientOffenvironment(id, userOrgID, patientOffenvironment)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"model":model,
		"patientOffenvironment":patientOffenvironment,
	})
	//environment, err := site_service.UpdateOfficeEnvironment(id, userOrgID)
	//if err !=nil{
	//	this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
	//	return
	//}
	//this.ServeSuccessJSON(map[string]interface{}{
	//	"environment":environment,
	//})
}

func (this *Microwebsite) Hispitalmore()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	id, _ := this.GetInt64("id")
	hospital, err := site_service.QueryHispitalDetail(userOrgID, id)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"hospital":hospital,
	})
}

func (this *Microwebsite) GetOfficeDetail()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	id, _ := this.GetInt64("id")
	fmt.Println("ID是多少",id)
	offices, err := site_service.GetOfficeDetail(userOrgID, id)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"offices":offices,
	})
}

func (this *Microwebsite) GetDoctorDetail()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	id, _ := this.GetInt64("id")
	fmt.Println("米公益ID",id)
	editdoctor, err := site_service.GetDoctorDetail(userOrgID, id)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"editdoctor":editdoctor,
	})
}

func (this *Microwebsite) GetOfficEnviromentDetail()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	id, _ := this.GetInt64("id")
	fmt.Println("科室环境id",id)
	offenvironment, err := site_service.GetOfficEnviromentDetail(userOrgID, id)
	fmt.Println("错误",err)
	fmt.Println("offenvironment",offenvironment)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"offenvironment":offenvironment,
	})
}

func  (this *Microwebsite) GetArticlistDetail()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println("机构id",userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("文章详情",id)
	articlelist, err := site_service.GetArticlelistById(id, userOrgID)
	fmt.Println(articlelist.Number,err)
	//fmt.Println(err)
	articlelists, err := site_service.GetAllArticles(userOrgID, articlelist.Number)
	fmt.Println("articlelist",articlelist)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"articlelists":articlelists,
	})
}

func (this *Microwebsite) GetActivitesDetail()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println("机构id",userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("活动详情",id)
	addactivity, err := site_service.GetAllActivitiById(id, userOrgID)
	fmt.Println("err",err)
	activity, err := site_service.GetAllActivities(userOrgID, addactivity.Number)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"activity":activity,
	})
}

func (this *Microwebsite) AddNavigation()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println("机构ID",userOrgID)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}

	navtitle := dataBody["navtitle"].(string)
	if len(navtitle) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "导航标题不能为空")
		return
	}

	fmt.Println("导航标题",navtitle)

	navigationImages := dataBody["navigationImages"].(string)
	if len(navigationImages) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "导航图片不能为空")
		return
	}
    fmt.Println("导航图片",navigationImages)
	nonavigationimages := dataBody["nonavigationImages"].(string)
	jumpset := int64(dataBody["jumpset"].(float64))
	if jumpset <= 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "跳转设置不能为空")
		return
	}
    fmt.Println("调转设置",jumpset)
	navigationaddress := dataBody["navigationaddress"].(string)
	fmt.Println("链接地址",navigationaddress)
	linkid := int64(dataBody["linkid"].(float64))
	fmt.Println("linkID",linkid)
	linktype := int64(dataBody["linktype"].(float64))
	navigation := models.SgjPatientNavigation{
		Navtitle:   navtitle,
		Navimages:  navigationImages,
		Nonavimages:nonavigationimages,
		Jumpset:    jumpset,
		Navaddress: navigationaddress,
		UserOrgId:userOrgID,
		Status: 1,
		Ctime:time.Now().Unix(),
		Linkid:linkid,
		Linktype:linktype,
	}
	err = site_service.AddNavigation(&navigation)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"navigation":navigation,
	})
}

func (this *Microwebsite) GetNavigationList()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	navigation, err := site_service.GetNavigationList(userOrgID)
	fmt.Println("导航错误是什么",err)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"navigation":navigation,
	})
}

func (this *Microwebsite) AddShareInfo()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println("机构ID",userOrgID)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}

	sharetitle := dataBody["sharetitle"].(string)
	fmt.Println("比阿尼",sharetitle)
	if len(sharetitle) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "分享标题不能为空")
		return
	}

	shareintroduction := dataBody["shareintroduction"].(string)
	fmt.Println("分享内容",sharetitle)
	if len(shareintroduction) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "分享标题不能为空")
		return
	}

	shareImages := dataBody["shareImages"].(string)
	fmt.Println("分享图片",shareImages)
	if len(shareImages) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "分享标题不能为空")
		return
	}

	share := models.SgjPatientShare{
		ShareTitle:        sharetitle,
		ShareIntroduction: shareintroduction,
		ShareImages:       shareImages,
		Ctime:             time.Now().Unix(),
		UserOrgId:userOrgID,
		Status:            1,
	}
    fmt.Println("share是设么",share)
	err = site_service.AddShareInfo(&share)

	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"share":share,
	})
}

func (this *Microwebsite) GetShareInfo()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	share, err := site_service.GetShareInfo(userOrgID)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	fmt.Println("错误是什么?",err)
	this.ServeSuccessJSON(map[string]interface{}{
		"share":share,
	})
	fmt.Println("返回share是什么",share)
}

func (this *Microwebsite) DeleteNavition()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	id, _ := this.GetInt64("id")
	fmt.Println("id是什么呢",id)
	err := site_service.DeleteNavitionById(userOrgID, id)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除成功")
		return
	}
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *Microwebsite) DeleteModle()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	id, _ := this.GetInt64("id")
	fmt.Println("模块ID",id)
	err := site_service.DeleteModle(userOrgID, id)
	fmt.Println("错误是什么",err)
	errtw := site_service.DeleteModleByModeID(userOrgID, id)
	way := site_service.DeleteRideWay(userOrgID, id)
	workTime := site_service.DeleteWorkTime(userOrgID, id)
	conrotation := site_service.DeleteConrotation(id, userOrgID)
	fmt.Println("错误是什么",errtw,way,workTime)
	fmt.Println(conrotation)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除成功")
		return
	}
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *Microwebsite) GetOrderModel()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	ordmodel, err := site_service.GetOrederModel(userOrgID)
     fmt.Println("ordemodel是社没什么",ordmodel)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"ordmodel":ordmodel,
	})
}

func  (this *Microwebsite) AddRotationpic()  {
	fmt.Println("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println("机构ID",userOrgID)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	images := dataBody["Images"].(string)
	fmt.Println("图片",images)
	if len(images) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "图片不能为空")
		return
	}

	sort := int64(dataBody["sort"].(float64))
	if sort <= 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "排序不能为空")
		return
	}
    fmt.Println("排序",sort)
	piclink := int64(dataBody["piclink"].(float64))
	if piclink <= 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "图片链接不能为空")
		return
	}
    fmt.Println("图片链接",piclink)
	linkaddress := dataBody["linkaddress"].(string)
	fmt.Println("链接地址",linkaddress)
	linkid := int64(dataBody["linkid"].(float64))
	fmt.Println("linkid是什么",linkid)
	conrotation := models.SgjPatientConrotation{
		Images:      images,
		Sort:        sort,
		Piclink:     piclink,
		Linkaddress: linkaddress,
		Status:      1,
		Ctime:       time.Now().Unix(),
		UserOrgId:   userOrgID,
		Modeid:0,
		ImgShow:1,
		Linkid:linkid,
	}

	err = site_service.AddRotationpic(conrotation)
	patientConrotation, err := site_service.GetPatientConrotationLast(userOrgID)
	fmt.Println("patientConrotation是设么",patientConrotation.ID)
	fmt.Println("err是什么",err)
	conrotations, total, err := site_service.GetTotalCount(userOrgID)
	fmt.Println("conrotations",conrotations)
	//conlinkaddress := models.SgjPatientConlinkaddress{
	//	ConId:patientConrotation.ID,
	//}
	//err = site_service.UpdateConLinkAddress(userOrgID, 0, conlinkaddress)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"total":total,
		"conrotation":conrotation,
	})
}

func (this *Microwebsite) GetRotationimages()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	conrotations, err := site_service.GetRotationImages(userOrgID)
	fmt.Println(conrotations)
	fmt.Println("海克斯错误是什么",err)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"conrotations":conrotations,
	})
}

func (this *Microwebsite) AddrotationImage()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	title := dataBody["title"].(string)
	fmt.Println("模块标题",title)
	if len(title) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "模块标题不能为空")
		return
	}

	sort := int64(dataBody["sort"].(float64))
	if sort<=0{
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong,"排序不能为空")
		return
	}
    fmt.Println("排序",sort)
	rotationImages := dataBody["rotationImages"]
	fmt.Println("图片",rotationImages)
	images := strings.Replace(strings.Trim(fmt.Sprint(rotationImages), "[]"), " ", ",", -1)
	fmt.Println("images",images)

	idsInters := dataBody["ids"].([]interface{})
	fmt.Println("id集合是",idsInters)
	if len(idsInters) == 0 {
		if err != nil {
			this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "删除会员失败:（没有选择会员）")
			return
		}
	}

	ids := make([]int64, 0)
	for _, idsInter := range idsInters {
		id := int64(idsInter.(float64))
		ids = append(ids, id)
	}
	ordmodel := models.SgjPatientOrdmodel{
		Title:    title,
		Sort:     sort,
		ModeType: 1,
		Ctime:time.Now().Unix(),
		Status:1,
		UserOrgId:userOrgID,

	}
	err = site_service.AddOrdModel(&ordmodel)
	fmt.Println("错苏是设么",err)
	patientOrdmodel, err := site_service.QueryOrdeModelByID(userOrgID)
	conrotation := models.SgjPatientConrotation{
		Modeid: patientOrdmodel.ID,
	}

	err = site_service.UpdateConrotaions(userOrgID, ids, conrotation)
	fmt.Println("rongfeng",err)
	oldrotation := models.SgjPatientOldrotation{
		Title:          title,
		Sort:           sort,
		RotationImages: images,
		ModeId:         patientOrdmodel.ID,
		Status:         1,
		UserOrgId:      userOrgID,
		Ctime:          time.Now().Unix(),
	}
	err = site_service.AddrotationImage(&oldrotation)
	patientConrotation := models.SgjPatientConrotation{
		Modeid: patientOrdmodel.ID,
	}
	err = site_service.UpdateConrotation(userOrgID, ids, patientConrotation)
	fmt.Println("错误",err)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"oldrotation":oldrotation,
	})
}

func (this *Microwebsite)  AddImageslink()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	id, _ := this.GetInt64("id")
	fmt.Println("id是多少",id)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	imageUrl := dataBody["imageUrl"].(string)
	fmt.Println("图片编辑",imageUrl)
	if len(imageUrl) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "图片编辑不能为空")
		return
	}
	sort := int64(dataBody["sort"].(float64))
	fmt.Println("排序",sort)
	if sort <= 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "排序不能为空")
		return
	}
	imagelink :=int64(dataBody["imagelink"].(float64))
	if imagelink <= 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "图片链接不能为空")
		return
	}
	fmt.Println("图片链接",imagelink)
	linkaddress := dataBody["linkaddress"].(string)
	editpiclink := models.SgjPatientEditpiclink{
		Images:      imageUrl,
		Sort:        sort,
		Piclink:     imagelink,
		Linkaddress: linkaddress,
		Status:      1,
		Ctime:       time.Now().Unix(),
		UserOrgId:   userOrgID,
		Modeid:0,
		ImgShow:1,
		Linkid:id,
	}

	err = site_service.AddImageslink(&editpiclink)
	edipiclink, total, err := site_service.GetCountImages(userOrgID)
	fmt.Println("错误是什么错误是什么错误是什么错误是什么错误是什么",err)
	fmt.Println(total)
	fmt.Println(edipiclink)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"editpiclink":editpiclink,
		"total":total,
	})
}

func (this *Microwebsite) GetEditImages()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	editpiclinks, err := site_service.GetEditImages(userOrgID)
	fmt.Println("查询到的数据",editpiclinks,err)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"editpiclinks":editpiclinks,
	})
}

func (this *Microwebsite) AddMagicNavi()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println("这个是",userOrgID)

	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	linkid := int64(dataBody["linkid"].(float64))
    fmt.Println("linkid是多少",linkid)
	margtitle := dataBody["margtitle"].(string)
	fmt.Println("导航标题",margtitle)
	if len(margtitle) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "导航标题不能为空")
		return
	}
	margImage := dataBody["margImage"].(string)
	fmt.Println("导航图标",margImage)
	if len(margtitle) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "导航图标不能为空")
		return
	}
	jumpset := int64(dataBody["jumpset"].(float64))
	fmt.Println("跳转设置",jumpset)
	if len(margtitle) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "跳转设置不能为空")
		return
	}
	marginaddress := dataBody["marginaddress"].(string)
	fmt.Println("链接地址",marginaddress)
	//if len(marginaddress) == 0 {
	//	this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "导航图标不能为空")
	//	return
	//}

	editmargin := models.SgjPatientEditmargin{
		Margtitle:     margtitle,
		Margimage:     margImage,
		Jumpset:       jumpset,
		Marginaddress: marginaddress,
		Status:        1,
		Ctime:         time.Now().Unix(),
		UserOrgId:     userOrgID,
		ImgShow:1,
		Modeid:0,
		Linkid:linkid,
	}

	err = site_service.AddMagicNavi(&editmargin)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"editmargin":editmargin,
	})
}

func (this *Microwebsite) GetMagicImages()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	editmargins, err := site_service.GetMagicImages(userOrgID)
	fmt.Println("错误",err)
	fmt.Println("editmargins",editmargins)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"editmargins":editmargins,
	})
}

func (this *Microwebsite) AddMarginChart()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println(userOrgID)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	title := dataBody["title"].(string)
	fmt.Println("图片编辑",title)
	if len(title) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "图片编辑不能为空")
		return
	}
	sort := int64(dataBody["sort"].(float64))
	fmt.Println("排序",sort)
	if  sort <= 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "图片编辑不能为空")
		return
	}
	macimages := dataBody["marginImages"]
	images := strings.Replace(strings.Trim(fmt.Sprint(macimages), "[]"), " ", ",", -1)
	fmt.Println("images",images)
	marginTitle := dataBody["margintTitle"]
	fmt.Println("魔方导航标题",marginTitle)
	margintitletwo := strings.Replace(strings.Trim(fmt.Sprint(marginTitle), "[]"), " ", ",", -1)
	fmt.Println("margintitle",margintitletwo)
	idsInters := dataBody["ids"].([]interface{})
	fmt.Println("id集合是",idsInters)
	if len(idsInters) == 0 {
		if err != nil {
			this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "删除会员失败:（没有选择会员）")
			return
		}
	}

	ids := make([]int64, 0)
	for _, idsInter := range idsInters {
		id := int64(idsInter.(float64))
		ids = append(ids, id)
	}
	model := models.SgjPatientModel{
		Title:     title,
		Sort:      sort,
		UserOrgId: userOrgID,
		Status:    1,
		Ctime:     time.Now().Unix(),
		ModeType:  8,
	}
	site_service.AddPatientModel(&model)
	fmt.Println("rotation是什么",model)
	patientModel, err := site_service.QueryModel(userOrgID)

	macnavigation := models.SgjPatientMacnavigation{
		Title:     title,
		Sort:      sort,
		MacImages: images,
		MacTitles:margintitletwo,
		Modeid:    patientModel.ID,
		Status:    1,
		Ctime:     time.Now().Unix(),
		UserOrgId: userOrgID,
	}
	err = site_service.AddMarginChart(&macnavigation)
	editmargin := models.SgjPatientEditmargin{
		Modeid: patientModel.ID,
	}
	err = site_service.UpdateEditMagin(userOrgID, ids, editmargin)
	fmt.Println("错误是中秋",err)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"macnavigation":macnavigation,
	})
}

func (this *Microwebsite) DeleteRotations(){
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	//fmt.Println("机构ID",userOrgID)
	id, _ := this.GetInt64("id")
	//fmt.Println("id是什么",id)
	err := site_service.DeleteRotations(id, userOrgID)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除图片失败")
		return
	}
	edipiclink, total, err := site_service.GetCountImages(userOrgID)
	fmt.Println("edipiclink",edipiclink)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"total":total,
	})
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func  (this *Microwebsite) EditRotationImages()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println(userOrgID)
	id, _ := this.GetInt64("id")
	//fmt.Println("id是什么",id)
	editpiclink, err := site_service.UpdateRotationImages(userOrgID, id)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"editpiclink":editpiclink,
	})
}

func (this *Microwebsite) SaveRotationImages()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println("",userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("id是什么",id)

	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	images := dataBody["images"].(string)
	fmt.Println("图片编辑",images)
	if len(images) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "图片编辑不能为空")
		return
	}
	sort :=int64(dataBody["sort"].(float64))
	fmt.Println("排序",sort)
   if(sort<=0){
   	  this.ServeFailJsonSend(enums.ErrorCodeParamWrong,"排序不能为空")
   	  return
   }
	piclink :=int64(dataBody["piclink"].(float64))
	fmt.Println("图片链接",piclink)
	if (piclink <= 0) {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "图片编辑不能为空")
		return
	}
	linkaddress := dataBody["linkaddress"].(string)

	fmt.Println("链接地址",linkaddress)

	editpiclink := models.SgjPatientEditpiclink{
		Images:      images,
		Sort:        sort,
		Piclink:     piclink,
		Linkaddress: linkaddress,
	}
	err = site_service.SaveRotationImages(id, userOrgID, editpiclink)
	fmt.Println("错误",err)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"editpiclink":editpiclink,
	})
}

func (this *Microwebsite) EditNavigation()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println("",userOrgID)
	id, _ := this.GetInt64("id")
	//fmt.Println("id是什么",id)
	navigation, err := site_service.EditNavigation(userOrgID,id)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"navigation":navigation,
	})
}

func (this *Microwebsite) SaveNavigation()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println("",userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("id是多少呢",id)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	navtitle := dataBody["navtitle"].(string)
	fmt.Println("导航标题",navtitle)
	if len(navtitle) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "图片编辑不能为空")
		return
	}
	navimages := dataBody["navimages"].(string)
	fmt.Println("导航图标选中",navimages)
	if len(navimages) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "图片编辑不能为空")
		return
	}

	noCheckImages := dataBody["nonavimages"].(string)
	fmt.Println("导航图标未选中",noCheckImages)
	if len(navimages) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "图片编辑不能为空")
		return
	}
	jumpset := int64(dataBody["jumpset"].(float64))
	fmt.Println("跳转设置",jumpset)
	if jumpset <= 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "图片编辑不能为空")
		return
	}
	navaddress := dataBody["navaddress"].(string)
	fmt.Println("链接地址",navaddress)
	linkid := int64(dataBody["linkid"].(float64))
	fmt.Println("linkid是多少",linkid)
	linktype := int64(dataBody["linktype"].(float64))
	navigation := models.SgjPatientNavigation{
		Navtitle:   navtitle,
		Navimages:  navimages,
        Nonavimages:noCheckImages,
		Jumpset:    jumpset,
		Navaddress: navaddress,
		Linkid:linkid,
		Linktype:linktype,
	}
	err = site_service.UpdateNavtion(id, userOrgID, navigation)
	navigations, err := site_service.GetDefaultNavigation(userOrgID)
	fmt.Println("err是什么",err)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"navigation":navigation,
		"navigations":navigations,
	})
}

func (this *Microwebsite) AddHospital()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println("机构ID",userOrgID)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	title := dataBody["title"].(string)
	fmt.Println("导航标题",title)
	if len(title) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "标题不能为空")
		return
	}
	sort := int64(dataBody["sort"].(float64))
	if sort<=0{
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong,"排序不能为空")
		return
	}
	fmt.Println("排序",sort)
	address :=dataBody["address"].(string)
	fmt.Println("医院地址",address)
	if len(address) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "标题不能为空")
		return
	}
	patientOrdmodel := models.SgjPatientOrdmodel{
		Title:     title,
		Sort:      sort,
		UserOrgId: userOrgID,
		Status:    1,
		Ctime:     time.Now().Unix(),
		ModeType: 2,
	}
	site_service.AddOrdModel(&patientOrdmodel)
	ordmodel, err := site_service.QueryOrdeModelByID(userOrgID)

	hosaddress := models.SgjPatientHosaddress{
		Title:     title,
		Sort:      sort,
		Address:   address,
		UserOrgId: userOrgID,
		Status:    1,
		Ctime:     time.Now().Unix(),
		Modeid:    ordmodel.ID,
	}
	err = site_service.AddHosAddress(&hosaddress)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"hosaddress":hosaddress,
	})
}

func (this *Microwebsite) DeleteImages()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println("机构ID",userOrgID)
	id, _:= this.GetInt64("id")
	fmt.Println("id是神么",id)
	err := site_service.DeleteImages(id, userOrgID)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	conrotation, total, err := site_service.GetTotalCount(userOrgID)
	fmt.Println("conrotation",conrotation)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"total":total,
	})
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *Microwebsite) DeleteSingleImages()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	id, _:= this.GetInt64("id")
	modeid, _ := this.GetInt64("modeid")
	fmt.Println("机构id",userOrgID)
	fmt.Println("编辑录播id",id)
	fmt.Println("模块id",modeid)
	err := site_service.DeleteSingleImages(id, userOrgID)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	edipiclink, total, err := site_service.GetDeleteImages(userOrgID,modeid)
	fmt.Println("total是什么",total)
	fmt.Println(edipiclink)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"total":total,
	})
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}


func (this *Microwebsite) AddActive()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println("机构ID",userOrgID)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	title := dataBody["title"].(string)
	fmt.Println("活动标题",title)
	if len(title) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "标题不能为空")
		return
	}
	sort := int64(dataBody["sort"].(float64))
	fmt.Println("排序",sort)
	number := int64(dataBody["number"].(float64))
	fmt.Println("条数",number)
	model := models.SgjPatientModel{
		Title:     title,
		Sort:      sort,
		Ctime:     time.Now().Unix(),
		UserOrgId: userOrgID,
		ModeType:  7,
		Status:    1,
	}
	site_service.AddPatientModel(&model)
	patientModel, err := site_service.QueryModel(userOrgID)
	addactivity := models.SgjPatientAddactivity{
		Title:     title,
		Sort:      sort,
		Number:    number,
		Ctime:     time.Now().Unix(),
		UserOrgId: userOrgID,
		Modeid:    patientModel.ID,
		Status:    1,
	}
	err = site_service.AddActivity(&addactivity)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"addactivity":addactivity,
	})
}

func (this *Microwebsite) GetActivity()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println("机构ID",userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("id是多少",id)
	addactivity, err := site_service.QueryActivity(id, userOrgID)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"addactivity":addactivity,
	})
}

func (this *Microwebsite) Saveactivit()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println("机构ID",userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("id是多少",id)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	title := dataBody["title"].(string)
	fmt.Println("活动标题",title)
	if len(title) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "标题不能为空")
		return
	}
	sort := int64(dataBody["sort"].(float64))
	fmt.Println("排序",sort)
	number := int64(dataBody["number"].(float64))
	fmt.Println("条数",number)
	modeid := int64(dataBody["modeid"].(float64))
	fmt.Println("模块ID",modeid)
	addactivity := models.SgjPatientAddactivity{
		Title:  title,
		Sort:   sort,
		Number: number,
	}
	model := models.SgjPatientModel{
		Title:  title,
		Sort:   sort,
	}
	err = site_service.UpdateModel(modeid, userOrgID, model)
	fmt.Println("错误",err)
	err = site_service.UpdateActivit(id, userOrgID, addactivity)
	fmt.Println("错误",err)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"addactivity":addactivity,
	})
}

func (this *Microwebsite) DeleteMargin()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println("机构ID",userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("id是什么",id)
	err := site_service.DeleteMargin(id, userOrgID)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *Microwebsite) GetRotationImages()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println("机构ID",userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("id是什么",id)
	//site_service.GetEditRotationImages(id)
}

func (this *Microwebsite) GetRotationDetail()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	//fmt.Println("机构ID",userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("海珍id是什么",id)
	oldrotation, err := site_service.GetEditRotationImages(id, userOrgID)
	conrotation, err := site_service.GetEditConrotion(id, userOrgID)
	fmt.Println("错误",err)
	fmt.Println(oldrotation)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"oldrotation":oldrotation,
		"conrotation":conrotation,
	})
}

func (this *Microwebsite)  EditVisibleById()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println("机构ID",userOrgID)
	id, _ := this.GetInt64("id")

	conrotation, err := site_service.EditVisibleById(id, userOrgID)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"conrotation":conrotation,
	})
}

func (this *Microwebsite) SaveEditpic()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println("机构ID",userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("海珍id是什么",id)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	images := dataBody["images"].(string)
	fmt.Println("图片",images)
	if len(images) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "标题不能为空")
		return
	}
	sort := int64(dataBody["sort"].(float64))
	fmt.Println("排序",sort)
	piclink := int64(dataBody["piclink"].(float64))
	fmt.Println("图片链接",piclink)
	linkaddress := dataBody["linkaddress"].(string)
	fmt.Println("链接地址",linkaddress)
	modeid := int64(dataBody["modeid"].(float64))
	fmt.Println("天梦中",modeid)
	conrotation := models.SgjPatientConrotation{
		Images:      images,
		Sort:        sort,
		Piclink:     piclink,
		Linkaddress: linkaddress,
	}
	err = site_service.UpdateEditpic(id, userOrgID,conrotation)
	fmt.Println("err错误",err)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	conrotations, err := site_service.QueryConRotation(modeid, userOrgID)
	fmt.Println("错误小小马",err)
	fmt.Println(conrotations)
	this.ServeSuccessJSON(map[string]interface{}{
		"conrotation":conrotation,
		"conrotations":conrotations,
	})
}

func (this *Microwebsite) AddEditpic()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println("机构ID",userOrgID)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	images := dataBody["images"].(string)
	fmt.Println("图片",images)
	if len(images) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "标题不能为空")
		return
	}
	sort := int64(dataBody["sort"].(float64))
	fmt.Println("排序",sort)
	piclink := int64(dataBody["piclink"].(float64))
	fmt.Println("图片链接",piclink)
	linkaddress := dataBody["linkaddress"].(string)
	fmt.Println("链接地址",linkaddress)
	id, _ := this.GetInt64("id")
	fmt.Println("下孟子id",id)
	oldrotation, err := site_service.QueryOldrotion(id, userOrgID)
	fmt.Println("oldrotation",oldrotation)
	conrotation := models.SgjPatientConrotation{
		Images:      images,
		Sort:        sort,
		Piclink:     piclink,
		Linkaddress: linkaddress,
		Status:      1,
		Modeid:      id,
		UserOrgId:   userOrgID,
		Ctime:time.Now().Unix(),
		ImgShow:1,
	}
	err = site_service.AddEditpic(&conrotation)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	conrotations, erros := site_service.QueryConRotation(id, userOrgID)
	fmt.Println("门前错误",erros)
	fmt.Println("conrotations是什么",conrotations)
	this.ServeSuccessJSON(map[string]interface{}{
		"conrotation":conrotation,
		"conrotations":conrotations,
	})
}

func (this *Microwebsite) AddEdialogVisible()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println("机构ID",userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("这个ID是",id)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	  title := dataBody["title"].(string)
	  fmt.Println("标题",title)
	  sort := int64(dataBody["sort"].(float64))
	  fmt.Println("排序",sort)
	  rotationImages := dataBody["rotationImages"]
	  images := strings.Replace(strings.Trim(fmt.Sprint(rotationImages), "[]"), " ", ",", -1)
	  fmt.Println("图片",images)

	oldrotation := models.SgjPatientOldrotation{
		Title:          title,
		Sort:           sort,
		RotationImages: images,
	}
	err = site_service.UpdateConrotaionById(id, userOrgID,oldrotation)
	fmt.Println(err)
	fmt.Println("马文强错错误是什么",err)
	ordmodel := models.SgjPatientOrdmodel{
		Title: title,
		Sort:  sort,
	}
	err = site_service.UpdateOrdeModel(id, userOrgID, ordmodel)

		if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"oldrotation":oldrotation,
		"ordmodel":ordmodel,
	})
}

func (this *Microwebsite) GetEditRotationimages()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println("编辑轮播图机构id",userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("id是多少?",id)
	model, err := site_service.GetPatientModel(id, userOrgID)
	fmt.Println("patientEditpiclink",model)
	fmt.Println("错误",err)
	editpiclink, err := site_service.QueryEditpiclink(id, userOrgID)
	fmt.Println("错误是多少",err)
	fmt.Println("返回数据",editpiclink)
	editpiclinks, total, err := site_service.QueryEditpiclinkCount(id, userOrgID)
	fmt.Println(editpiclinks)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}

	this.ServeSuccessJSON(map[string]interface{}{
		"model":model,
		"editpiclink":editpiclink,
		"total":total,
	})

}

func (this *Microwebsite) GetEditSingleVisible()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println("机构id",userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("id是多少?",id)
	editpiclink, err := site_service.GetEditSingleVisible(id, userOrgID)

	fmt.Println("错误",err)
	fmt.Println("editpiclink",editpiclink)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"editpiclink":editpiclink,
	})
}

func (this *Microwebsite) UpdateSingleForm()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println("机构id",userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("id是多少",id)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	images := dataBody["images"].(string)
	fmt.Println("图片",images)
	sort := int64(dataBody["sort"].(float64))
	fmt.Println("排序",sort)
	piclink := int64(dataBody["piclink"].(float64))
	fmt.Println("图片链接",piclink)
    linkaddress := dataBody["linkaddress"].(string)
    fmt.Println("链接地址",linkaddress)
	modelid := int64(dataBody["modeid"].(float64))
	linkid := int64(dataBody["linkid"].(float64))
	editpiclink := models.SgjPatientEditpiclink{
		Images:      images,
		Sort:        sort,
		Piclink:     piclink,
		Linkaddress: linkaddress,
		Linkid:linkid,
	}
	err = site_service.UpdateEditPatPicLink(id, userOrgID, editpiclink)
	fmt.Println("第一个错误是设么",err)
	patientEditpiclink, err := site_service.GetQueryEditpiclink(modelid, userOrgID)
	fmt.Println("错误是多",err)
    fmt.Println("pateientEditpiclink是多少",patientEditpiclink)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"editpiclink":editpiclink,
		"patientEditpiclink":patientEditpiclink,
	})

}

func (this *Microwebsite) AddEditPicForm()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println("机构id",userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("这个广告id是多少?",id)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	images := dataBody["images"].(string)
	fmt.Println("图片",images)
	sort := int64(dataBody["sort"].(float64))
	fmt.Println("排序",sort)
	piclink := int64(dataBody["piclink"].(float64))
	fmt.Println("图片链接",piclink)
	linkaddress := dataBody["linkaddress"].(string)
	fmt.Println("链接地址",linkaddress)
	linkid := int64(dataBody["linkid"].(float64))

	//patientRotation, err := site_service.GetPatientRotationById(id, userOrgID)
	//fmt.Println("错误",err)
	//fmt.Println("rotation数据",patientRotation)
	editpiclink := models.SgjPatientEditpiclink{
		Images:      images,
		Sort:        sort,
		Piclink:     piclink,
		Linkaddress: linkaddress,
		UserOrgId:   userOrgID,
		Ctime:       time.Now().Unix(),
		Status:      1,
		Modeid:      id,
		ImgShow:1,
		Linkid:linkid,
	}
	err = site_service.AddImageslink(&editpiclink)
	editpiclinks, err := site_service.GetPicImages(userOrgID, id)
	fmt.Println("oooooooooooooooooooooooobbbbbbbbbbbbbb")
	fmt.Println("err",err)
	edipiclink, total, err := site_service.GetCountPicImages(userOrgID, id)
	fmt.Println(edipiclink)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"editpiclinks":editpiclinks,
		"editpiclink":editpiclink,
		"total":total,
	})
}

func (this *Microwebsite) AddRotationVisible()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println("机构id",userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("编辑轮播id是多少",id)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	title := dataBody["title"].(string)
	fmt.Println("编辑轮播标题",title)
	 sort:= int64(dataBody["sort"].(float64))
	 fmt.Println("编辑轮播排序",sort)
	images := dataBody["images"]
	fmt.Println("编辑轮播图片",images)
	image:= strings.Replace(strings.Trim(fmt.Sprint(images), "[]"), " ", ",", -1)
	//fmt.Println(image)
	patientRotation := models.SgjPatientRotation{
		Title:          title,
		Sort:           sort,
		RotationImages: image,
	}
	//err = site_service.UpdateRotationByid(id, userOrgID, patientRotation)
	//fmt.Println("这个错误是设么",err)
	two := site_service.UpdateEditPicLinkTwo(id, userOrgID)
	fmt.Println("two",two)
	model := models.SgjPatientModel{
		Title:     title,
		Sort:      sort,
	}
	//rotation, err := site_service.GetPatientRotationById(id, userOrgID)
	//fmt.Println("错误",err)
	err = site_service.UpdateModelById(id, userOrgID, model)
	fmt.Println("这个错误",err)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"patientRotation":patientRotation,
		 "model":model,
	})
}

func (this *Microwebsite) GetEditImagesDetail()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println("机构id",userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("海珍id是多少",id)
	editmargin, err := site_service.QuerEditMarginById(id, userOrgID)
	fmt.Println("错误",err)
	fmt.Println("editmargin",editmargin)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"editmargin":editmargin,
	})
}

func (this *Microwebsite) UpdateEditMacgin()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println("机构id",userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("id是",id)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	margtitle := dataBody["margtitle"].(string)
	fmt.Println("导航标题",margtitle)
	margimage := dataBody["margimage"].(string)
	fmt.Println("导航图标",margimage)
	jumpset := int64(dataBody["jumpset"].(float64))
	fmt.Println("跳转设置",jumpset)
	marginaddress := dataBody["marginaddress"].(string)
	fmt.Println("地址",marginaddress)
	editmargin := models.SgjPatientEditmargin{
		Margtitle:     margtitle,
		Margimage:     margimage,
		Jumpset:       jumpset,
		Marginaddress: marginaddress,
	}
	err = site_service.UpdateMarginById(id, userOrgID, editmargin)
	fmt.Println("错误",err)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"editmargin":editmargin,
	})
}

func (this *Microwebsite) GetActivities()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	//fmt.Println("我爱你中国")
	//fmt.Println("机构id",userOrgID)
	addactivity, err := site_service.GetActivitiesById(userOrgID)
	//fmt.Println("错误",err)
	//fmt.Println("活动限制",addactivity.Number)
	activity, err := site_service.GetAllActivities(userOrgID, addactivity.Number)
	//fmt.Println("错误",err)
	//fmt.Println("火气大",activity)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"activity":activity,
	})
}

func  (this *Microwebsite) GetArticleType()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	category, err := site_service.GetArticleType(userOrgID)
	fmt.Println("错误",err)
	fmt.Println("文章分类",category)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"category":category,
	})
}

func (this *Microwebsite) AddArticelist()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println("机构id",userOrgID)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	title := dataBody["title"].(string)
	fmt.Println("标题",title)
	if len(title)==0 {
	   title = "暂无数据"
	}
	//category := int64(dataBody["category"].(float64))
	//fmt.Println("文章分类",category)
	//categoryone := int64(dataBody["categoryone"].(float64))
	//fmt.Println("文章分类2",categoryone)
	number := int64(dataBody["number"].(float64))
	fmt.Println("展示数据",number)
	sort := int64(dataBody["sort"].(float64))
	fmt.Println("排序",sort)
	model := models.SgjPatientModel{
		Title:     title,
		Sort:      sort,
		UserOrgId: userOrgID,
		Status:    1,
		Ctime:     time.Now().Unix(),
		ModeType:6,
	}
	 site_service.AddPatientModel(&model)
	patientModel, err := site_service.QueryModel(userOrgID)
	articlelist := models.SgjPatientArticlelist{
		Title:       title,
		Sort:        sort,
		UserOrgId:   userOrgID,
		Status:      1,
		Ctime:       time.Now().Unix(),
		Number:      number,
		Modeid:      patientModel.ID,
	}
	err = site_service.AddActiclelist(&articlelist)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"articlelist":articlelist,
	})
}

func (this *Microwebsite) GetArticlelist()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println("文章机构id",userOrgID)
	articlelist, err := site_service.GetArticlelist(userOrgID)
	fmt.Println("articlelist",articlelist)
	fmt.Println("错误",err)
	fmt.Println(articlelist.Number)
	articlelists, err := site_service.GetAllArticles(userOrgID, articlelist.Number)
	fmt.Println("文章列表",articlelists)
	fmt.Println("错误",err)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"articlelists":articlelists,
	})
}

func (this *Microwebsite) EditGetArticlistDetail()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println("机构id",userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("id是多少?",id)
	articlelist, err := site_service.GetArticlelistById(id, userOrgID)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"articlelist":articlelist,
	})
}

func (this *Microwebsite) SaveArticeDetail()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := int64(adminUserInfo.CurrentOrgId)
	fmt.Println("机构id",userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("获取id是多少?",id)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	title := dataBody["title"].(string)
	fmt.Println("活动标题",title)
	if len(title) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "标题不能为空")
		return
	}
	sort := int64(dataBody["sort"].(float64))
	fmt.Println("排序",sort)
	number := int64(dataBody["number"].(float64))
	fmt.Println("条数",number)
	modeid := int64(dataBody["modeid"].(float64))
	fmt.Println("模块ID",modeid)
	model := models.SgjPatientModel{
		Title: title,
		Sort:  sort,
	}
	err = site_service.UpdateModel(modeid, userOrgID, model)
	fmt.Println("错误",err)
	articlelist := models.SgjPatientArticlelist{
		Title:  title,
		Sort:   sort,
		Number: number,
	}
	err = site_service.UpdateArticeDetail(id, userOrgID, articlelist)
	fmt.Println("错误",err)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"articlelist":articlelist,
		"model":model,
	})
}

func(this *Microwebsite) GetMacImages()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	id, _:= this.GetInt64("id")
	fmt.Println("机构id",userOrgID)
	fmt.Println("导航图标",id)
	model, err := site_service.GetModelById(id, userOrgID)
	fmt.Println("错误是设么",err)
	fmt.Println("model是什么",model)
	macnavigation, err := site_service.GetMacImagesByModeid(id, userOrgID)
	fmt.Println("中袖返回数据",macnavigation)
	fmt.Println("错误",err)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"macnavigation":macnavigation,
		"model":model,
	})
}

func (this *Microwebsite) GetEnImages()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id",userOrgID)
	enviroimages, err := site_service.GetEnImages(userOrgID)
	fmt.Println("错误",err)
	fmt.Println("enviroimages",enviroimages)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"enviroimages":enviroimages,
	})
}

func (this *Microwebsite) GetEditEnvirimages()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id",userOrgID)
	id,_ := this.GetInt64("id")
	fmt.Println("id是",id)
	enviroimages, err := site_service.GetEditEnvirimagesById(userOrgID, id)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"enviroimages":enviroimages,
	})
}

func (this *Microwebsite) AddTwoImages()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id",userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("id是",id)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	enviroimages := dataBody["enviroimages"].(string)
	fmt.Println("活动标题",enviroimages)
	if len(enviroimages) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "标题不能为空")
		return
	}
	sort:= int64(dataBody["sort"].(float64))
	fmt.Println("排序",sort)
	patientEnviroimages := models.SgjPatientEnviroimages{
		Enviroimages: enviroimages,
		Sort:         sort,
	}
	err = site_service.UpdateEnviroimages(id, userOrgID, patientEnviroimages)
	fmt.Println("错误",err)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"patientEnviroimages":patientEnviroimages,
	})
}

func (this *Microwebsite)  AddOfficeThree()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id",userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("科室环境id是",id)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	officeImages := dataBody["officeImages"].(string)
	fmt.Println("活动标题",officeImages)
	if len(officeImages) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "标题不能为空")
		return
	}
	sort:= int64(dataBody["sort"].(float64))
	fmt.Println("排序",sort)
	offenvironment, err := site_service.GetOffENvironmentById(id, userOrgID)
	fmt.Println("offenvironment",offenvironment)
	enviroimages := models.SgjPatientEnviroimages{
		Enviroimages: officeImages,
		Sort:         sort,
		UserOrgId:    userOrgID,
		Status:       1,
		Ctime:        time.Now().Unix(),
		Modeid:       id,
	}
	err = site_service.AddOfficeThree(&enviroimages)
	fmt.Println("err",err)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	patientEnviroimages, err := site_service.GetQueryImages(id, userOrgID)
	this.ServeSuccessJSON(map[string]interface{}{
		"enviroimages":enviroimages,
		"patientEnviroimages":patientEnviroimages,
	})
}

func (this *Microwebsite) GetOfficeTwoVisible()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id",userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("id是",id)
	enviroimages, err := site_service.GetOfficeTwoVisible(userOrgID, id)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"enviroimages":enviroimages,
	})
}

func  (this *Microwebsite) AddOfficeTwo()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id",userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("id是",id)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	officeImages := dataBody["officeImages"].(string)
	fmt.Println("活动标题",officeImages)
	if len(officeImages) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "标题不能为空")
		return
	}
	sort:= int64(dataBody["sort"].(float64))
	fmt.Println("排序",sort)
	modelid := int64(dataBody["modelid"].(float64))
	fmt.Println("小泽",modelid)
	enviroimages := models.SgjPatientEnviroimages{
		Enviroimages: officeImages,
		Sort:         sort,
	}
	err = site_service.UpdateOfficeTwo(userOrgID, id, enviroimages)
	patientEnviroimages, err := site_service.GetQueryEnviroimage(userOrgID, modelid)
	fmt.Println("错误是什么",err)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"enviroimages":enviroimages,
		"patientEnviroimages":patientEnviroimages,
	})
}

func  (this *Microwebsite) DeleteOfficeById()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id",userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("id是",id)
	err := site_service.DeleteOfficeById(id, userOrgID)
	fmt.Println("错误",err)
	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this *Microwebsite) GetArticleById()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id",userOrgID)
	articTypeid, _ := this.GetInt64("id")
	fmt.Println("id是",articTypeid)
	articlelist, err := site_service.GetArticleById(articTypeid, userOrgID)
	fmt.Println("错误",err)
	fmt.Println("articlelist",articlelist)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"articlelist":articlelist,
	})
}

func (this *Microwebsite) GetAllActivity()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id",userOrgID)
	activtity, err := site_service.GetAllActivity(userOrgID)
	fmt.Println("活动列表",activtity)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"activtity":activtity,
	})
}
func (this *Microwebsite) AddData()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id",userOrgID)

	defineaddress := this.GetString("address")
	fmt.Println("站位地址",defineaddress)
	patientLinkaddress := models.SgjPatientLinkaddress{
		Defineaddress: defineaddress,
		UserOrgId:     userOrgID,
		Status:        1,
		Ctime:         time.Now().Unix(),
	}
	err := site_service.AddLinkAddress(&patientLinkaddress)
	fmt.Println("错误是设么",err)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"patientLinkaddress":patientLinkaddress,
	})
}


func  (this *Microwebsite) Getlinkaddress()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id",userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("id",id)
	linkaddress, err := site_service.GetLinkAddress(userOrgID,id)
	fmt.Println("错误",err)
	fmt.Println("地址",linkaddress)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"linkaddress":linkaddress,
	})
}

func (this *Microwebsite) GetAllConnecway()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id",userOrgID)
	connect, err := site_service.GetAllConnecway(userOrgID)
	fmt.Println("错误是什么",err)
	fmt.Println("connect是设么",connect)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"connect":connect,
	})
}

func  (this *Microwebsite) GetConnecway()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id",userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("id是",id)
	ordmodel, err:= site_service.GetConnecway(userOrgID, id)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"ordmodel":ordmodel,
	})
}

func (this *Microwebsite) GetConnecwayById()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id",userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("id是",id)
	connection, err := site_service.GetConnecwayById(userOrgID, id)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"connection":connection,
	})
}

func (this *Microwebsite) UpdateConnectway() {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id", userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("id是",id)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	title := dataBody["title"].(string)
	fmt.Println("标题",title)
	connecway := int64(dataBody["connecway"].(float64))
	fmt.Println("联系方式",connecway)
	content := dataBody["content"].(string)
	fmt.Println("内容",content)
	connection := models.SgjPatientConnection{
		Title:     title,
		Connecway: connecway,
		Content:   content,
	}
	err = site_service.UpdateConnectway(id, userOrgID, connection)
	fmt.Println("错误",err)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"connection":connection,
	})
}

func (this *Microwebsite) UpdateContact()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id", userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("id是",id)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	title := dataBody["title"].(string)
	fmt.Println("标题",title)
	sort := int64(dataBody["sort"].(float64))
	fmt.Println("排序",sort)
	ordmodel := models.SgjPatientOrdmodel{
		Title: title,
		Sort:  sort,
	}
	connectway := models.SgjPatientConnectway{
		Title: title,
		Sort:  sort,
	}
	err = site_service.UpdateOrdeModel(id, userOrgID, ordmodel)
	err = site_service.UpdateConnectways(id, userOrgID, connectway)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"ordmodel":ordmodel,
		"connectway":connectway,
	})

}

func (this *Microwebsite) AddConnectways()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id", userOrgID)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	title := dataBody["title"].(string)
	fmt.Println("标题",title)
	connecway := int64(dataBody["connecway"].(float64))
	fmt.Println("联系方式",connecway)
	content := dataBody["content"].(string)
	connection := models.SgjPatientConnection{
		Title:     title,
		Connecway: connecway,
		Content:   content,
		UserOrgId: userOrgID,
		Ctime:     time.Now().Unix(),
		Status:    1,
	}
	err = site_service.AddConnectways(&connection)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"connection":connection,
	})
}

func (this *Microwebsite) GetHostpitalIntroduction()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id", userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("id是",id)
	ordmodel, err := site_service.GetHostpitalIntroduction(userOrgID, id)
	hosaddress, err := site_service.GetHostpitaAddress(userOrgID, id)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"ordmodel":ordmodel,
		"hosaddress":hosaddress,
	})

}

func (this *Microwebsite) UpdateHospitalAddress()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id", userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("id是",id)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	title := dataBody["title"].(string)
	fmt.Println("标题",title)
	sort := int64(dataBody["sort"].(float64))
	fmt.Println("排序",sort)
	address := dataBody["hosaddress"].(string)
	fmt.Println("地址",address)
	ordmodel := models.SgjPatientOrdmodel{
		Title: title,
		Sort:  sort,
	}
	hosaddress := models.SgjPatientHosaddress{
		Title:title,
		Sort:sort,
		Address:address,
	}
	err = site_service.UpdateOrdeModel(id, userOrgID, ordmodel)
	err = site_service.UpdateHosAddress(id, userOrgID, hosaddress)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"ordmodel":ordmodel,
		"hosaddress":hosaddress,
	})
}

func (this *Microwebsite) AddPicLinkAddress()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id", userOrgID)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	defineaddress := dataBody["defineaddress"].(string)
	fmt.Println("defineaddress",defineaddress)
	conlinkaddress := models.SgjPatientConlinkaddress{
		Defineaddress: defineaddress,
		UserOrgId:     userOrgID,
		Status:        1,
		Ctime:         time.Now().Unix(),
	}
	err  = site_service.AddConlinkaddress(&conlinkaddress)
	fmt.Println("错误",err)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"conlinkaddress":conlinkaddress,
	})
}

func  (this *Microwebsite) GetLinkAddressDetail()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id", userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("链接id",id)
	conlinkaddress, err := site_service.GetLinkAddressDetail(userOrgID, id)
	fmt.Println("错误",err)
	fmt.Println("conlinkaddress",conlinkaddress)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"conlinkaddress":conlinkaddress,
	})
}

func (this *Microwebsite) UpdatePicFformThree()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id好", userOrgID)
	id, _:= this.GetInt64("id")
	fmt.Println("id",id)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	defineaddress := dataBody["defineaddress"].(string)
	fmt.Println("defineaddress",defineaddress)
	conlinkaddress := models.SgjPatientConlinkaddress{
		Defineaddress: defineaddress,
	}
	err = site_service.UpdatedConlinkAddress(id, userOrgID, conlinkaddress)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"conlinkaddress":conlinkaddress,
	})

}

func (this *Microwebsite) GetEnImagesTwo()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	editpiclink, err := site_service.GetEnImagesTwo(userOrgID)
	fmt.Println("次哦啊",err)
	fmt.Println("editpiclink是设么",editpiclink)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"editpiclink":editpiclink,
	})
}

func (this *Microwebsite) GetEnImagesThree()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	conrotation, err := site_service.GetEnImagesThree(userOrgID)
	fmt.Println("conrotation是傻子",conrotation)
	fmt.Println("cer",err)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"conrotation":conrotation,
	})
}

func (this *Microwebsite) AddMagiclinkData()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构ID",userOrgID)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	linkType := int64(dataBody["linkType"].(float64))
	fmt.Println("链接类型",linkType)
	Instationlink := int64(dataBody["instationlink"].(float64))
	fmt.Println("站内链接",Instationlink)
	//intstationlink, err := strconv.ParseInt(Instationlink, 10, 64)
	//articeType := int64(dataBody["articeType"].(float64))
	//fmt.Println("文章分类",articeType)
	phone := dataBody["phone"].(string)
	fmt.Println("电话号码",phone)
	outstationlink := dataBody["outstationlink"].(string)
	fmt.Println("站外链接",outstationlink)

	magiclink := models.SgjPatientMagiclink{
		Linktype:       linkType,
		Instationlink:  Instationlink,
		Phone:          phone,
		Outstationlink: outstationlink,
		Ctime:time.Now().Unix(),
		Status:1,
		UserOrgId:userOrgID,
	}
	err = site_service.AddMagiclinkData(&magiclink)
	fmt.Println("错误",err)
	model, err := site_service.GetPatienModelByModelId(Instationlink, userOrgID)
	fmt.Println("错误",err)
	fmt.Println("model",model)
	this.ServeSuccessJSON(map[string]interface{}{
		"magiclink":magiclink,
		"model":model,
	})
}

func  (this *Microwebsite) GetMacLinkAddress()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构ID",userOrgID)
	magiclink, err := site_service.GetMacLinkAddress(userOrgID)
	fmt.Println("magiclink",magiclink)
	fmt.Println("中秋梦玲",err)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"magiclink":magiclink,
	})
}

func (this *Microwebsite) AddMacgicform() {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构ID", userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("id是多少", id)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	title := dataBody["title"].(string)
	fmt.Println("导航标题", title)
	macgicimages := dataBody["macgicimages"].(string)
	fmt.Println("导航图标", macgicimages)
	jumpset := int64(dataBody["jumpset"].(float64))
	fmt.Println("跳转设置", jumpset)
	linkaddress := dataBody["linkaddress"].(string)
	fmt.Println("链接地址", linkaddress)
	editmargin := models.SgjPatientEditmargin{
		Margtitle:     title,
		Margimage:     macgicimages,
		Jumpset:       jumpset,
		Marginaddress: macgicimages,
		UserOrgId:userOrgID,
		Modeid:        id,
		Status:        1,
		Ctime:         time.Now().Unix(),
	}
	err = site_service.AddMacgicform(&editmargin)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"editmargin":editmargin,
	})
}

func (this *Microwebsite) GetMacImagesDetail()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构ID", userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("id是多少", id)
	editmargin, err := site_service.GetMacImagesDetail(userOrgID, id)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"editmargin":editmargin,
	})
}

func (this *Microwebsite) DeleteMacImagesDetail()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构ID", userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("id是多少", id)
	err := site_service.DeletMacImagesDetail(id, userOrgID)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "删除回复成功")
		return
	}

	returnData := make(map[string]interface{}, 0)
	returnData["msg"] = "ok"
	this.ServeSuccessJSON(returnData)
	return
}

func (this*Microwebsite) UpdateMacForm()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构ID", userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("id是多少", id)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	title := dataBody["title"].(string)
	fmt.Println("导航标题", title)
	sort := int64(dataBody["sort"].(float64))
	fmt.Println("排序",sort)
	model := models.SgjPatientModel{
		Title: title,
		Sort:  sort,
	}
	err = site_service.UpdateModel(id, userOrgID, model)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"model":model,
	})
}

func (this*Microwebsite) GetEditMacImageDetail()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构中秋ID", userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("机构宗秀id",id)
	editmargin, err := site_service.GetEditMacImageDetailById(userOrgID, id)
	fmt.Println("ditmargin",editmargin)
	fmt.Println("错误",err)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"editmargin":editmargin,
	})
}

func (this*Microwebsite) UpdateEditMacForm()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构中秋ID", userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("中秋id",id)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	margtitle := dataBody["margtitle"].(string)
	fmt.Println("导航标题", margtitle)
	margimage := dataBody["margimage"].(string)
	fmt.Println("导航图片",margimage)
	jumpset := int64(dataBody["jumpset"].(float64))
	fmt.Println("导航设置",jumpset)
	marginaddress := dataBody["marginaddress"].(string)
	fmt.Println("导航图标链接地址",marginaddress)
	editmargin := models.SgjPatientEditmargin{
		Margtitle:     margtitle,
		Margimage:     margimage,
		Jumpset:       jumpset,
		Marginaddress: marginaddress,
	}
	err = site_service.UpdateEditMacFormById(id, userOrgID, editmargin)
	fmt.Println("爆粗",err)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"editmargin":editmargin,
	})
}

func (this*Microwebsite) GetLikeMacAddressById()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	//fmt.Println("机构中秋ID", userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("中秋id",id)
	magiclink, err := site_service.GetLikeMacAddressById(userOrgID, id)
	fmt.Println("中秋快乐",magiclink)
	fmt.Println("错误",err)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"magiclink":magiclink,
	})
}

func (this*Microwebsite) GetArticleName()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("ID", userOrgID)
	id, _ := this.GetInt64("id")
	articlelist, err := site_service.GetArticleById(id, userOrgID)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"articlelist":articlelist,
	})
}

func  (this*Microwebsite) GetAllArticeList()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	articles, err := site_service.GetAllArticeList(userOrgID)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"articles":articles,
	})
}

func  (this*Microwebsite) UpdateLinkAddress()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id", userOrgID)
	id, _:= this.GetInt64("id")
	fmt.Println("id",id)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	linktype := int64(dataBody["linktype"].(float64))
	fmt.Println("链接类型",linktype)
	instationlink := int64(dataBody["instationlink"].(float64))
	fmt.Println("站类李恩杰",instationlink)
	//articetype := int64(dataBody["articetype"].(float64))
	//fmt.Println("文章类型",articetype)
	//title := int64(dataBody["title"].(float64))
	//fmt.Println("文章標題",title)
	phone := dataBody["phone"].(string)
	fmt.Println("電話",phone)
	outstationlink := dataBody["outstationlink"].(string)
	fmt.Println("展望列哪家",outstationlink)
	linkaddress := int64(dataBody["linkaddress"].(float64))
	formatInt := strconv.FormatInt(linkaddress, 10)
	fmt.Println("链接地址",linkaddress)
	if(phone != ""){
		formatInt = phone;
	}
	if(outstationlink != ""){
		formatInt = outstationlink;
	}
	magiclink := models.SgjPatientMagiclink{
		Linktype:       linktype,
		Instationlink:  instationlink,
		Phone:          phone,
		Outstationlink: outstationlink,
		Linkaddress:    formatInt,
		UserOrgId:userOrgID,
		Status:1,
	}
	model, err := site_service.GetPatienModelByModelId(linkaddress, userOrgID)
	patientMagiclink, err := site_service.GetMacLinkAddressTwo(userOrgID)
	fmt.Println("长度",len(patientMagiclink))
	if(len(patientMagiclink)== 0){
		err = site_service.AddMacLinkAddress(&magiclink)
		fmt.Println("err",err)
	}else {
		fmt.Println(magiclink)
		err = site_service.UpdateLinkAddress(id, userOrgID, magiclink)
	}
	fmt.Println("报错误",err)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"magiclink":magiclink,
		"model":model,
	})
}

func  (this*Microwebsite) AddMacLinkAddress()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id", userOrgID)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	linktype := int64(dataBody["linktype"].(float64))
	fmt.Println("linktype",linktype)
	instationlink := int64(dataBody["instationlink"].(float64))
	fmt.Println("instationlink",instationlink)
	phone := dataBody["phone"].(string)
	fmt.Println("phone",phone)
	outstationlink := dataBody["outstationlink"].(string)
	fmt.Println("outtationlink",outstationlink)
	magiclink := models.SgjPatientMagiclink{
		Linktype:       linktype,
		Instationlink:  instationlink,
		Phone:          phone,
		Outstationlink: outstationlink,
		Ctime:          time.Now().Unix(),
		Status:         1,
	}
	fmt.Println("magiclink",magiclink)
	err = site_service.AddMacLinkAddress(&magiclink)
	model, err := site_service.GetPatienModelByModelId(instationlink, userOrgID)
	fmt.Println(err)
	//patientMagiclink, err := site_service.GetMacLinkAddress(userOrgID)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"magiclink":magiclink,
		"model":model,
	})

}

func  (this*Microwebsite) GetLinkAddress()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id", userOrgID)
	id, _:= this.GetInt64("id")
	fmt.Println("id",id)
	linkaddress, err := site_service.GetPatientLinkAddress(id, userOrgID)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"linkaddress":linkaddress,
	})
}

func (this*Microwebsite) GetCountImages()  {
	fmt.Println("")
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id机构id记过id九宫UID", userOrgID)
	edipiclink, total, err := site_service.GetCountImages(userOrgID)
	fmt.Println("edipiclink是什么edipiclink是什么edipiclink是什么edipiclink是什么",edipiclink)
	fmt.Println("total是什么",total)
	fmt.Println("err是什么",err)
}

func (this*Microwebsite) AddNavigationLinkform()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id", userOrgID)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	linktype := int64(dataBody["linktype"].(float64))
	fmt.Println("linktype",linktype)
	navitionlinktype := int64(dataBody["navitionlinktype"].(float64))
	fmt.Println("navitionlinktype",navitionlinktype)
	phone := dataBody["phone"].(string)
	if(phone == "0"){
		phone = ""
	}
	fmt.Println("phone",phone)

	outstationlink := dataBody["outstationlink"].(string)
	if(outstationlink == "0"){
		outstationlink = ""
	}
	fmt.Println("outstationlink",outstationlink)
	linkaddress := dataBody["linkaddress"].(string)
	fmt.Println("linkaddress",linkaddress)
	navgationlink := models.PatientNavgationlink{
		Linktype:         linktype,
		Navitionlinktype: navitionlinktype,
		Phone:            phone,
		Outstationlink:   outstationlink,
		Status:           1,
		Ctime:            time.Now().Unix(),
		Linkaddress:linkaddress,
		UserOrgId:userOrgID,
	}
	err = site_service.AddNavitaionLinkAddress(&navgationlink)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"navgationlink":navgationlink,
	})

}

func (this*Microwebsite) GetNavigationlinkaddress()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id", userOrgID)
	id,_ := this.GetInt64("id")
	fmt.Println("id是什么",id)
	navgationlink, err := site_service.GetNavgationlinkAddressBylinkId(userOrgID, id)
	fmt.Println("大错误",err)
	fmt.Println(navgationlink)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"navgationlink":navgationlink,
	})
}

func (this*Microwebsite) UpdateditnavigationLink() {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id", userOrgID)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	//id := int64(dataBody["id"].(float64))
		//fmt.Println("id是什么",id)
	id, _ := this.GetInt64("id")
	fmt.Println("id是什么",id)

	linktype := int64(dataBody["linktype"].(float64))
	fmt.Println("linktype",linktype)
	navitionlinktype := int64(dataBody["navitionlinktype"].(float64))
	fmt.Println("navitionlinktype",navitionlinktype)
	phone := dataBody["phone"].(string)
	fmt.Println("phone",phone)
	outstationlink := dataBody["outstationlink"].(string)
	fmt.Println("outstationlink",outstationlink)
	linkaddress := dataBody["linkaddress"].(string)
	fmt.Println("linkaddress",linkaddress)
	navgationlink := models.PatientNavgationlink{
		Linktype:         linktype,
		Navitionlinktype: navitionlinktype,
		Outstationlink:   outstationlink,
		Linkaddress:      linkaddress,
		Phone:phone,
		UserOrgId:userOrgID,
		Status:1,
	}
	patientNavgationlink, errcode := site_service.GetNavgationLinkById(id, userOrgID)
	fmt.Println(patientNavgationlink,errcode)
	if errcode == gorm.ErrRecordNotFound{
		err = site_service.AddNavigationlink(&navgationlink)
		fmt.Println("数据添加成功",err)
	}else if errcode == nil {
		err = site_service.UpdateditnavigationLink(id, userOrgID, navgationlink)
		if err !=nil{
			this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
			return
		}
	}else {
		err = site_service.UpdateditnavigationLink(id, userOrgID, navgationlink)
		if err !=nil{
			this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
			return
		}
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"navgationlink":navgationlink,
	})

}

func (this*Microwebsite)  AddDoctorInfoTwo()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id", userOrgID)
	id,_ := this.GetInt64("id")
	fmt.Println("这个id",id)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	name := dataBody["name"].(string)
	fmt.Println("姓名",name)
	usertitle := int64(dataBody["user_title"].(float64))
	fmt.Println("职称",usertitle)
	dochead := dataBody["dochead"].(string)
	fmt.Println("医生头像",dochead)
	sort := int64(dataBody["sort"].(float64))
	fmt.Println("排序",sort)
	content := dataBody["content"].(string)
	fmt.Println("内容",content)
	editdoctor := models.SgjPatientEditdoctor{
		DocName:         name,
		DocPostion:      usertitle,
		Dochead:         dochead,
		DocSort:         sort,
		Docintroduction: content,
		Modleid:         id,
		UserOrgId:       userOrgID,
		Status:          1,
		Ctime:           time.Now().Unix(),
		ImgShow: 1,
	}

	err = site_service.AddEditDoctor(&editdoctor)
	editdoctors, err := site_service.QuerEditDoctorInfo(id, userOrgID)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"editdoctor":editdoctor,
		"editdoctors":editdoctors,
	})
}

func (this*Microwebsite)  GetUserOrgID(){
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id", userOrgID)
	this.ServeSuccessJSON(map[string]interface{}{
		"usreOrgID":userOrgID,
	})
}

func (this *Microwebsite) GetNavigationset()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id", userOrgID)
	//navigation, err := site_service.GetDefaultNavigation(userOrgID)
	//fmt.Println("错误是设么",err)
	//if (len(navigation) == 0) {
	//	sgjPatientNavigation := models.SgjPatientNavigation{
	//		Navtitle:   "首页",
	//		Navimages:  "https://images.shengws.com/2099_o_1570840397245.png",
	//		Nonavimages:"https://images.shengws.com/2099_o_1570840397245.png",
	//		Jumpset:    1,
	//		Navaddress: "",
	//		Ctime:      time.Now().Unix(),
	//		Status:     1,
	//		UserOrgId:  userOrgID,
	//	}
	//	err = site_service.AddDefaultData(&sgjPatientNavigation)
	//	patientNavigation := models.SgjPatientNavigation{
	//		Navtitle:   "微商城",
	//		Navimages:  "https://images.shengws.com/2122_o_1570840361702.png",
	//		Nonavimages:"https://images.shengws.com/2122_o_1570840361702.png",
	//		Jumpset:    1,
	//		Navaddress: "http://shop.kuyicloud.com/app/index.php?i=2&c=entry&m=ewei_shopv2&do=mobile&fxtoken=bdc5659cbd1bd67baa9af215b0d6ae4c&fxorgid=3877&timestamp=1571050598&fxadmin=185&wxref=mp.weixin.qq.com#wechat_redirect",
	//		Ctime:      time.Now().Unix(),
	//		Status:     1,
	//		UserOrgId:  userOrgID,
	//	}
	//	err = site_service.AddDefaultData(&patientNavigation)
	//	fmt.Println(err)
     //   fmt.Println(patientNavigation)
	//	sgjPatientNavigationtwo := models.SgjPatientNavigation{
	//		Navtitle:   "联系我们",
	//		Navimages:  "https://images.shengws.com/2138_o_1570840377129.png",
	//		Nonavimages:"https://images.shengws.com/2138_o_1570840377129.png",
	//		Jumpset:    1,
	//		Navaddress: "",
	//		Ctime:      time.Now().Unix(),
	//		Status:     1,
	//		UserOrgId:  userOrgID,
	//	}
	//	err = site_service.AddDefaultData(&sgjPatientNavigationtwo)
	//	fmt.Println(err)
     //  fmt.Println(sgjPatientNavigationtwo)
	//	sgjPatientNavigationthree := models.SgjPatientNavigation{
	//		Navtitle:   "在线客服",
	//		Navimages:  "https://images.shengws.com/2079_o_1570842501972.png",
	//		Nonavimages:"https://images.shengws.com/2079_o_1570842501972.png",
	//		Jumpset:    1,
	//		Navaddress: "0755-86526342",
	//		Ctime:      time.Now().Unix(),
	//		Status:     1,
	//		UserOrgId:  userOrgID,
	//	}
	//	err = site_service.AddDefaultData(&sgjPatientNavigationthree)
	//	fmt.Println(err)
     //   fmt.Println(sgjPatientNavigationthree)
	//
	//	navigations, err := site_service.GetDefaultNavigation(userOrgID)
	//	fmt.Println(err)
	//	if err !=nil{
	//		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
	//		return
	//	}
	//	this.ServeSuccessJSON(map[string]interface{}{
	//		"sgjPatientNavigation":sgjPatientNavigation,
	//		"navigations":navigations,
	//	})
	//}

	navigations, err := site_service.GetDefaultNavigation(userOrgID)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"navigations":navigations,
	})
}

func (this *Microwebsite) GetNavigationData()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id", userOrgID)
	navigation, err := site_service.GetDefaultNavigation(userOrgID)
	fmt.Println("navigation是什么呢",navigation)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"navigation":navigation,
	})
}

func (this *Microwebsite) GetAllModelTitle(){
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id", userOrgID)
	patientModels, err := site_service.GetAllModelTitle(userOrgID)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"patientModels":patientModels,
	})
}


func (this *Microwebsite) GetDoctorDetailInfo(){
	id, _ := this.GetInt64("id")
	fmt.Println("医生详情id",id)
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id",userOrgID)
	editdoctor, err := site_service.GetDoctorDetailInfo(id, userOrgID)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"editdoctor":editdoctor,
	})
}

func (this *Microwebsite) GetArticleListDetail()  {
	id, _ := this.GetInt64("id")
	fmt.Println("文章详情id",id)
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id",userOrgID)
	articles, err := site_service.GetArticleListDetail(id, userOrgID)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"articles":articles,
	})
}

func (this *Microwebsite)  GetActivitiesListDetail()  {
	id, _ := this.GetInt64("id")
	fmt.Println("活动详情id",id)
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id",userOrgID)
	activity, err := site_service.GetActivitiesListDetail(id, userOrgID)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"activity":activity,
	})
}

func (this *Microwebsite) AddLinkAddressThree()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id",userOrgID)
	defineaddress := this.GetString("address")
	fmt.Println("自定义地址",defineaddress)
	if len(defineaddress) == 0 {
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "自定义地址不能为空")
		return
	}
	patientLinkaddress := models.SgjPatientLinkaddress{
		Defineaddress: defineaddress,
		UserOrgId:userOrgID,
		Status:1,
		Ctime:time.Now().Unix(),
	}
	err := site_service.AddLinkAddress(&patientLinkaddress)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"patientLinkaddress":patientLinkaddress,
	})
}

func (this *Microwebsite) GetLinkAddressByLinkId()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id",userOrgID)
	linkid, _ := this.GetInt64("linkid")
	fmt.Println("linkid是多少?",linkid)
	linkaddress, err := site_service.GetLinkAddressByLinkId(userOrgID, linkid)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"linkaddress":linkaddress,
	})
}

func (this *Microwebsite) AddLinkAddressFour()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id",userOrgID)
	address := this.GetString("address")
	fmt.Println("linkid是多少?",address)
	linkaddress := models.SgjPatientLinkaddress{
		Defineaddress: address,
		Status:        1,
		Ctime:         time.Now().Unix(),
		UserOrgId:     userOrgID,
	}

	err := site_service.AddLinkAddress(&linkaddress)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"linkaddress":linkaddress,
	})
}

func (this *Microwebsite) GetMagicLinkAddressById()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id",userOrgID)
	id, _:= this.GetInt64("id")
	fmt.Println("id是多少",id)
	magiclink, err := site_service.GetMagicLinkAddressById(userOrgID, id)
	fmt.Println("错误是什么",err)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"magiclink":magiclink,
	})
}

func (this *Microwebsite) GetMagicClickByLinkID()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id",userOrgID)
	linkid, _:= this.GetInt64("linkid")
	fmt.Println("id是多少",linkid)
	magiclink, err := site_service.GetMagicClickByLinkID(userOrgID, linkid)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"magiclink":magiclink,
	})
}

func (this *Microwebsite) GeteditRotationEmages()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id",userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("id",id)
	conrotation, err := site_service.GetEditRotationEmages(id, userOrgID)
	fmt.Println("错误",err)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"conrotation":conrotation,
	})
}

func (this *Microwebsite) GetOutRotationLink()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id",userOrgID)
	linkid, _ := this.GetInt64("id")
	fmt.Println("id",linkid)
	conlinkaddress, err := site_service.GetOutRotationLink(userOrgID, linkid)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"conlinkaddress":conlinkaddress,
	})
}

func (this *Microwebsite) UpdatedRolinkAddress()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id",userOrgID)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	//id := int64(dataBody["id"].(float64))
	id,_ := this.GetInt64("id")
	fmt.Println("id是什么",id)
	defineaddress :=dataBody["defineaddress"].(string)
	fmt.Println("defineaddress",defineaddress)
	conlinkaddress := models.SgjPatientConlinkaddress{
		Defineaddress: defineaddress,
	}
	err = site_service.UpdatedConlinkAddress(id, userOrgID, conlinkaddress)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"conlinkaddress":conlinkaddress,
	})
}

func (this *Microwebsite) UpdatedConrotation(){
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id",userOrgID)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	id, _ := this.GetInt64("id")
	fmt.Println("id是什么",id)
	images := dataBody["images"].(string)
	fmt.Println("images是什么",images)
	sort := int64(dataBody["sort"].(float64))
	fmt.Println("sort",sort)
	piclink := int64(dataBody["piclink"].(float64))
	fmt.Println("piclink",piclink)
	linkaddress := dataBody["linkaddress"].(string)
	fmt.Println("linkaddress",linkaddress)
	conrotation := models.SgjPatientConrotation{
		Images:      images,
		Sort:        sort,
		Piclink:     piclink,
		Linkaddress: linkaddress,
	}
	err = site_service.UpdatedConrotation(id, userOrgID, conrotation)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"conrotation":conrotation,
	})
}

func (this *Microwebsite) GetRotationVisibleByLinkId()  {
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id",userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("id是什么",id)
	conlinkaddress, err := site_service.GetRotationVisibleByLinkId(id, userOrgID)
	fmt.Println("错误",err)
	fmt.Println("conlinkaddress",conlinkaddress)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"conlinkaddress":conlinkaddress,
	})
}

func (this *Microwebsite)  AddRotationVisibleForm(){
	adminUserInfo := this.GetAdminUserInfo()
	userOrgID := adminUserInfo.CurrentOrgId
	fmt.Println("机构id",userOrgID)
	id, _ := this.GetInt64("id")
	fmt.Println("id是设么",id)
	dataBody := make(map[string]interface{}, 0)
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &dataBody)
	if err != nil {
		utils.ErrorLog(err.Error())
		this.ServeFailJsonSend(enums.ErrorCodeParamWrong, "参数错误")
		return
	}
	defineaddress := dataBody["defineaddress"].(string)
	fmt.Println("defineaddrss",defineaddress)
	linkaddress := models.SgjPatientLinkaddress{
		Defineaddress: defineaddress,
	}
	err = site_service.UpdatedRotationVisble(id, userOrgID, linkaddress)
	if err !=nil{
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"linkaddress":linkaddress,
	})
}