scrm/controllers/site/site_controller.go

package site

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

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")
	beego.Router("/api/site/getOrgName", &Microwebsite{}, "Get:GetOrgName")
}

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() {
	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)
	linkid := int64(dataBody["linkid"].(float64))
	fmt.Println("linkid", linkid)
	if piclink == 1 {
		conlinkaddress, err := site_service.UpdatedConAddress(linkid, userOrgID)
		fmt.Println("错误", err)
		fmt.Println("conlinkaddress", conlinkaddress)
	}
	conrotation := models.SgjPatientConrotation{
		Images:      images,
		Sort:        sort,
		Piclink:     piclink,
		Linkaddress: linkaddress,
		Linkid:      linkid,
	}
	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))
	if piclink == 1 {
		patientLinkaddress, err := site_service.UpdatedPatientLinkAddress(linkid, userOrgID)
		fmt.Println("hhhhhhhhhhhhhhhhhhherr错误", err)
		fmt.Println("patientlinkaddress", patientLinkaddress)
	}
	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,
		UserOrgId:     userOrgID,
		Status:        1,
		Ctime:         time.Now().Unix(),
	}
	//err = site_service.UpdatedConlinkAddress(id, userOrgID, conlinkaddress)
	err = site_service.AddConlinkAddress(&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,
	})
}

func (this *Microwebsite) GetOrgName() {
	orgid, _ := this.GetInt64("orgid")
	name, err := site_service.GetOrgName(orgid)
	if err != nil {
		this.ServeFailJsonSend(enums.ErrorCodeDataException, "更改数据失败")
		return
	}
	this.ServeSuccessJSON(map[string]interface{}{
		"name": name,
	})
}