package oilsupplier

import (
	"dashoo.cn/backend/api/business/audithistory"
	"dashoo.cn/backend/api/business/baseUser"
	msg2 "dashoo.cn/backend/api/business/msg"
	"dashoo.cn/backend/api/business/oilsupplier/infochange"
	"dashoo.cn/backend/api/business/oilsupplier/oilcostmanage"
	"dashoo.cn/backend/api/business/oilsupplier/qualchange"
	"dashoo.cn/backend/api/business/oilsupplier/suppliercert"
	"dashoo.cn/backend/api/business/oilsupplier/suppliercertappend"
	"dashoo.cn/backend/api/business/oilsupplier/supplierfile"
	"dashoo.cn/backend/api/business/oilsupplier/supplierlog"
	"dashoo.cn/backend/api/business/oilsupplier/tableheader"
	"dashoo.cn/backend/api/business/organize"
	"dashoo.cn/backend/api/business/paymentinfo"
	"dashoo.cn/backend/api/business/register"
	"dashoo.cn/business2/areajson"
	"dashoo.cn/business2/items"
	"dashoo.cn/business2/permission"
	"dashoo.cn/business3/parameter"
	"log"
	"reflect"

	"encoding/json"
	"fmt"
	"strconv"
	"strings"
	"time"

	"dashoo.cn/backend/api/business/auditsetting"

	"dashoo.cn/backend/api/business/oilsupplier/annualaudit"
	"dashoo.cn/backend/api/business/oilsupplier/supplier"
	"dashoo.cn/backend/api/business/workflow"

	"dashoo.cn/business2/userRole"

	. "dashoo.cn/backend/api/controllers"
	"dashoo.cn/utils"
)

type AnnualAuditController struct {
	BaseController
}

type ShenHeModel struct {
	AnnualId      int
	SuccessStatus int
	AuditorRemark string
}

type ComShenHeModel struct {
	SupplierId       int
	SupplierTypeName string
	Remark           string
}

// @Title 获取列表
// @Description get user by token
// @Success 200 {object} []annualaudit.OilAnnualAudit
// @router /list [get]
func (this *AnnualAuditController) GetEntityList() {

	//获取分页信息
	page := this.GetPageInfoForm()
	where := " b.Id is not null "
	orderby := "b.Id"
	asc := false
	Order := this.GetString("Order")
	Prop := this.GetString("Prop")
	if Order != "" && Prop != "" {
		orderby = Prop
		if Order == "asc" {
			asc = true
		}
	}
	if orderby == "SupplierName" {
		orderby = "a.SupplierName"
	}
	SupplierTypeName := this.GetString("SupplierTypeName")
	RecUnitId := this.GetString("RecUnitId")
	AccessCardNo := this.GetString("AccessCardNo")
	SupplierName := this.GetString("SupplierName")
	CreateOn := this.GetString("CreateOn")

	if SupplierTypeName != "" {
		where = where + " and b.SupplierTypeName like '%" + SupplierTypeName + "%'"
	}

	if RecUnitId != "" {
		where = where + " and b.RecUnitId like '%" + RecUnitId + "%'"
	}

	if AccessCardNo != "" {
		where = where + " and b.AccessCardNo like '%" + AccessCardNo + "%'"
	}

	if SupplierName != "" {
		where = where + " and b.SupplierName like '%" + SupplierName + "%'"
	}

	if CreateOn != "" {
		dates := strings.Split(CreateOn, ",")
		if len(dates) == 2 {
			minDate := dates[0]
			maxDate := dates[1]
			where = where + " and b.CreateOn>='" + minDate + "' and b.CreateOn<='" + maxDate + "'"
		}
	}
	svc := annualaudit.GetOilAnnualAuditService(utils.DBE)
	var registerUser register.OilCorporateInfo
	// TODO 这里应该从主表取企业信息，增项 年审和信息变更可能会改变企业信用代码(或者在申请通过后同步更新注册表)
	sql := " UserName='" + this.User.Username + "' and CheckStatus = 11 "
	svc.GetEntity(&registerUser, sql)
	//企业用户必须加创建人条件
	if this.User.IsCompanyUser == 1 {
		where = where + " and (b.CreateUserId = '" + this.User.Id + "' or a.CommercialNo='" + registerUser.CommercialNo + "')"
	} else {
		//超级管理员和有查看所有数据权限的用户不加条件
		svcPerm := permission.GetPermissionService(utils.DBE)
		isauth := svcPerm.IsAuthorized(this.User.Id, "oil_supplier.annual.AllRecord")
		if !svcPerm.IsAdmin(this.User.Id) && !isauth {
			where = where + " and (b.CreateUserId = '" + this.User.Id + "' or a.CommercialNo='" + registerUser.CommercialNo + "')"
		}
	}
	var list []annualaudit.OilAnnualAudit
	//total := svc.GetPagingEntitiesWithOrderBytbl("", page.CurrentPage, page.Size, orderby, asc, &list, where)
	total := svc.GetMyPagingEntitiesWithOrderBytbl(OilSupplierName, OilAnnualAuditName, page.CurrentPage, page.Size, orderby, asc, &list, where)
	var datainfo DataInfo
	datainfo.Items = list
	datainfo.CurrentItemCount = total
	datainfo.PageIndex = page.CurrentPage
	datainfo.ItemsPerPage = page.Size
	this.Data["json"] = &datainfo
	this.ServeJSON()
}

// @Title 获取审批列表
// @Description get user by token
// @Success 200 {object} []annualaudit.OilAnnualAudit
// @router /mytasks [get]
func (this *AnnualAuditController) GetMyTaskEntityList() {

	//获取分页信息
	page := this.GetPageInfoForm()
	where := " 1=1 "
	orderby := "Id"
	asc := false
	Order := this.GetString("Order")
	Prop := this.GetString("Prop")
	if Order != "" && Prop != "" {
		orderby = Prop
		if Order == "asc" {
			asc = true
		}
	}
	SupplierTypeName := this.GetString("SupplierTypeName")
	RecUnitId := this.GetString("RecUnitId")
	AccessCardNo := this.GetString("AccessCardNo")
	SupplierName := this.GetString("SupplierName")
	CreateOn := this.GetString("CreateOn")

	if SupplierTypeName != "" {
		where = where + " and SupplierTypeName like '%" + SupplierTypeName + "%'"
	}

	if RecUnitId != "" {
		where = where + " and RecUnitId like '%" + RecUnitId + "%'"
	}

	if AccessCardNo != "" {
		where = where + " and AccessCardNo like '%" + AccessCardNo + "%'"
	}

	if SupplierName != "" {
		where = where + " and SupplierName like '%" + SupplierName + "%'"
	}

	if CreateOn != "" {
		dates := strings.Split(CreateOn, ",")
		if len(dates) == 2 {
			minDate := dates[0]
			maxDate := dates[1]
			where = where + " and CreateOn>='" + minDate + "' and CreateOn<='" + maxDate + "'"
		}
	}

	svc := annualaudit.GetOilAnnualAuditService(utils.DBE)
	var list []annualaudit.OilAnnualAudit
	//找出待办任务
	actisvc := workflow.GetActivitiService(utils.DBE)
	certIdList := actisvc.GetMyTasks(workflow.OIL_AUDIT_APPLY, this.User.Id)
	annuIdarr := strings.Split(certIdList, ",")
	for i, item := range annuIdarr {
		idx := strings.Index(item, "-")
		if idx >= 0 {
			annuIdarr[i] = strings.Split(item, "-")[0]
		}
	}
	certIdList = strings.Join(annuIdarr, ",")
	var total int64 = 0
	if certIdList != "" {
		where += " and Id in (" + certIdList + ")"
		//根据部门查询待办任务
		where += " and Status > 0 "
		total = svc.GetPagingEntitiesWithOrderBytbl("", page.CurrentPage, page.Size, orderby, asc, &list, where)
		//total := svc.GetMyPagingEntitiesWithOrderBytbl(OilSupplierName, OilSupplierCertName, page.CurrentPage, page.Size, orderby, asc, &list, where)

	}
	var datainfo DataInfo
	datainfo.Items = list
	datainfo.CurrentItemCount = total
	datainfo.PageIndex = page.CurrentPage
	datainfo.ItemsPerPage = page.Size
	this.Data["json"] = &datainfo
	this.ServeJSON()
}

// @Title 获取年审企业名称
// @Description 获取实体
// @Success 200 {object} annualaudit.OilAnnualAudit
// @router /supplierlist [get]
func (this *AnnualAuditController) GetSupplierList() {
	code := this.GetString("code")
	svc := infochange.GetInfoChangeService(utils.DBE)
	var supplierlist []annualaudit.Suppliername
	where := "1=1"
	//企业用户必须加创建人条件
	if this.User.IsCompanyUser == 1 {
		where = where + " and a.CreateUserId = '" + this.User.Id + "'"
	}
	//else {
	//	//超级管理员和有查看所有数据权限的用户不加条件
	//	svcPerm := permission.GetPermissionService(utils.DBE)
	//	isauth := svcPerm.IsAuthorized(this.User.Id, "oil_supplier.marketAccess.AllRecord")
	//	if !svcPerm.IsAdmin(this.User.Id) && !isauth {
	//		where = where + " and a.CreateUserId = '" + this.User.Id + "'"
	//	}
	//}

	if code != "" {
		where = where + " and b.SupplierTypeCode='" + code + "' "
	}
	where = where + " and b.Status='" + suppliercert.STORE_STATUS + "' "
	supplierlist = svc.GetSupplierList(""+OilSupplierName, where)
	var datainfo DataInfo
	datainfo.Items = supplierlist
	this.Data["json"] = &datainfo
	this.ServeJSON()
}

// @Title 获取字典列表
// @Description get user by token
// @Success 200 {object} map[string]interface{}
// @router /dictlist [get]
func (this *AnnualAuditController) GetDictList() {
	dictList := make(map[string]interface{})
	dictSvc := items.GetItemsService(utils.DBE)
	userSvc := baseUser.GetBaseUserService(utils.DBE)
	areaJsonSvc := areajson.GetAreaJsonService(utils.DBE)
	//customerSvc := svccustomer.GetCustomerService(utils.DBE)
	dictList["UnitRelation"] = dictSvc.GetKeyValueItems("UnitRelation")
	dictList["CompanyType"] = dictSvc.GetKeyValueItems("CompanyType")
	var userEntity userRole.Base_User
	userSvc.GetEntityById(this.User.Id, &userEntity)
	dictList["Supervisers"] = userSvc.GetUserListByDepartmentId(this.User.AccCode, userEntity.Departmentid)
	dictList["GaodeMapChinaAreas"] = areaJsonSvc.GetGaodeMapChinaAreas()
	//获取我创建的所有公司
	var list []supplier.OilSupplier
	if this.User.IsCompanyUser == 1 {
		svcSupplier := supplier.GetOilSupplierService(utils.DBE)
		supplierWhere := " CreateUserId = '" + this.User.Id + "'"
		svcSupplier.GetEntitysByWhere(OilSupplierName, supplierWhere, &list)
		dictList["CompanyNames"] = list
	} else { //二级单位不用获取
		dictList["CompanyNames"] = list
	}
	// 部门
	orgsvc := organize.GetOrganizeService(utils.DBE)
	dictList["Organizes"] = orgsvc.GetCollectionDetailviewlist("'" + this.User.AccCode + "'")
	//获得有专业审核接收权限的人员
	var users1 []userRole.Base_RoleList
	var auditWorkflow1 auditsetting.Base_OilAuditSetting
	rsvc := auditsetting.GetOilAuditSettingService(utils.DBE)
	rsvc.GetAuditStepRoleEntity(OilAuditSettingName, "100000172", workflow.PROF_RECE, &auditWorkflow1)
	users1 = rsvc.GetUserByRole(strconv.Itoa(auditWorkflow1.RoleId), "")
	dictList["Receive"] = users1
	//获得有专业审核权限的人员
	var users []userRole.Base_RoleList
	var auditWorkflow auditsetting.Base_OilAuditSetting
	rsvc.GetAuditStepRoleEntity(OilAuditSettingName, "100000172", workflow.PROF_AUDIT, &auditWorkflow)
	users = rsvc.GetUserByRole(strconv.Itoa(auditWorkflow.RoleId), "")
	dictList["ProfAudit"] = users
	var datainfo DataInfo
	datainfo.Items = dictList
	this.Data["json"] = &datainfo
	this.ServeJSON()

}

// @Title 获取实体
// @Description 获取实体
// @Success 200 {object} annualaudit.OilAnnualAudit
// @router /get/:id [get]
func (this *AnnualAuditController) GetEntity() {
	Id := this.Ctx.Input.Param(":id")

	var model annualaudit.OilAnnualAudit
	svc := annualaudit.GetOilAnnualAuditService(utils.DBE)
	svc.GetEntityByIdBytbl(""+OilAnnualAuditName, Id, &model)

	this.Data["json"] = &model
	this.ServeJSON()
}

// @Title 获取公司信息
// @Description 根据创建用户Id和增项类别号获取公司信息
// @Success 200 {object}
// @router /getsupplier [get]
func (this *AnnualAuditController) GetSupplier() {
	SuppTypeCode := this.GetString("SuppTypeCode")
	svc := annualaudit.GetOilAnnualAuditService(utils.DBE)
	where := "1=1 "
	if SuppTypeCode != "" {
		where = " WHERE b.Id is NOT NULL AND a.SupplierTypeCode = '" + SuppTypeCode + "' and (a.InFlag='1' or a.InFlag='2')"
	} else {
		where = " WHERE b.Id is NOT NULL AND (a.InFlag='1' or a.InFlag='2')"
	}
	var registerUser register.OilCorporateInfo
	sql := " UserName='" + this.User.Username + "' and CheckStatus = 11 "
	svc.GetEntity(&registerUser, sql)
	//企业用户必须加创建人条件
	if this.User.IsCompanyUser == 1 {
		where = where + " and (b.CreateUserId = '" + this.User.Id + "' or b.CommercialNo='" + registerUser.CommercialNo + "')"
		//if this.User.IsCompanyUser == 1 {
		//	where = where + " and b.CreateUserId = '" + this.User.Id + "'"
	}

	sqlStr := "SELECT b.Id AS SupplierId, a.Id AS SupplierCertId, b.SupplierName AS SupplierName FROM OilSupplierCert a LEFT JOIN OilSupplier b ON a.SupplierId = b.Id "
	sqlStr = sqlStr + where

	model, _ := svc.DBE.QueryString(sqlStr)

	this.Data["json"] = &model
	this.ServeJSON()
}

// @Title 获取公司信息（信息变更专用）
// @Description 根据创建用户Id和增项类别号获取公司信息
// @Success 200 {object}
// @router /getsupplierforchange [get]
func (this *AnnualAuditController) GetSupplierForChange() {
	SuppTypeCode := this.GetString("SuppTypeCode")
	svc := annualaudit.GetOilAnnualAuditService(utils.DBE)
	where := "1=1 "
	if SuppTypeCode != "" {
		where = " WHERE b.Id is NOT NULL AND a.SupplierTypeCode = '" + SuppTypeCode + "' and (a.InFlag='1' or a.InFlag='2' or a.Status='8')"
	} else {
		where = " WHERE b.Id is NOT NULL AND (a.InFlag='1' or a.InFlag='2' or a.Status='8')"
	}
	var registerUser register.OilCorporateInfo
	sql := " UserName='" + this.User.Username + "' and CheckStatus = 11 "
	svc.GetEntity(&registerUser, sql)
	//企业用户必须加创建人条件
	if this.User.IsCompanyUser == 1 {
		where = where + " and (b.CreateUserId = '" + this.User.Id + "' or b.CommercialNo='" + registerUser.CommercialNo + "')"
		//if this.User.IsCompanyUser == 1 {
		//	where = where + " and b.CreateUserId = '" + this.User.Id + "'"
	}

	sqlStr := "SELECT b.Id AS SupplierId, a.Id AS SupplierCertId, b.SupplierName AS SupplierName FROM OilSupplierCert a LEFT JOIN OilSupplier b ON a.SupplierId = b.Id "
	sqlStr = sqlStr + where

	model, _ := svc.DBE.QueryString(sqlStr)

	this.Data["json"] = &model
	this.ServeJSON()
}

// @Title 添加
// @Description 直接新增年审
// @Success	200	{object} controllers.Request
// @router /adddirect [post]
func (this *AnnualAuditController) AddEntityDirect() {
	var model annualaudit.OilAnnualAudit
	var errInfo ErrorDataInfo
	var jsonBlob = this.Ctx.Input.RequestBody
	svc := annualaudit.GetOilAnnualAuditService(utils.DBE)
	json.Unmarshal(jsonBlob, &model)
	supWhere := "a.Id = " + utils.ToStr(model.SupplierId) + " and b.SupplierTypeCode = '" + model.SupplierTypeName + "' and b.Status = '8' "
	supSvc := supplier.GetOilSupplierService(utils.DBE)
	var list []supplier.OilSupplierView
	supSvc.GetMyPagingEntitiesWithOrderBytbl(OilSupplierName, OilSupplierCertName, 1, 1, "a.Id", true, &list, supWhere)
	var supplierModel supplier.OilSupplierView
	supplierModel = list[0]
	model.AccessCardNo = supplierModel.AccessCardNo
	model.RecUnitId = supplierModel.RecUnitId
	model.CerId, _ = strconv.Atoi(supplierModel.CertId)
	model.ApplyTime = supplierModel.ApplyTime
	model.Status = "0"
	model.Step = 1
	model.BackReason = supplierModel.BackReason
	model.CreateOn = time.Now()
	model.CreateBy = this.User.Realname
	model.CreateUserId, _ = utils.StrTo(this.User.Id).Int()
	//添加一条年审记录
	_, err := svc.InsertEntityBytbl(""+OilAnnualAuditName, &model)
	if err == nil {
		//新增
		errInfo.Message = "添加成功！"
		errInfo.Code = 0
		errInfo.Item = model.Id
		this.Data["json"] = &errInfo
		this.ServeJSON()
	} else {
		errInfo.Message = "添加失败！" + utils.AlertProcess(err.Error())
		errInfo.Code = -1
		this.Data["json"] = &errInfo
		this.ServeJSON()
	}
}

// @Title 修改实体
// @Description 修改实体
// @Success	200	{object} controllers.Request
// @router /suppupdate/:id/:type/:instyle [post]
func (this *AnnualAuditController) UpdateSuppEntity() {
	id := this.Ctx.Input.Param(":id")
	typeCode := this.Ctx.Input.Param(":type")
	instyle := this.Ctx.Input.Param(":instyle")
	var errinfo ErrorInfo
	if id == "" {
		errinfo.Message = "操作失败！请求信息不完整"
		errinfo.Code = -2
		this.Data["json"] = &errinfo
		this.ServeJSON()
		return
	}

	var model supplier.OilSupplier
	var jsonBlob = this.Ctx.Input.RequestBody
	json.Unmarshal(jsonBlob, &model)

	var list []supplier.OilSupplierView
	service := supplier.GetOilSupplierService(utils.DBE)
	service.CheckUpdateRepeatApplyInfo(OilSupplierName, OilSupplierCertName, typeCode, strconv.Itoa(model.Id), model.SupplierName, model.CommercialNo, model.OrganCode, model.BankAccount, model.CompanyUrl, &list)
	if len(list) > 0 {
		errinfo.Message = "修改失败！ 已存在相关企业的信息，或与其他企业信息重复"
		errinfo.Code = -1
		this.Data["json"] = &errinfo
		this.ServeJSON()
		return
	}

	svc := supplier.GetOilSupplierService(utils.DBE)
	model.ModifiedOn = time.Now()
	model.ModifiedBy = this.User.Realname
	model.ModifiedUserId, _ = utils.StrTo(this.User.Id).Int()

	//判断基本信息是否可修改
	//updateCols := svc.GetUpdateCols(OilSupplierCertName, typeCode, model.Id)
	updateCols := []string{
		"SupplierName",
		"OilCertificateNo",
		"Grade",
		"MgrUnit",
		"OperType",
		"Country",
		"MaunAgent",
		"ConstructTeam",
		"CommercialNo",
		"OrganCode",
		"CountryTaxNo",
		"LocalTaxNo",
		"Address",
		"Province",
		"City",
		"Street",
		"HouseNo",
		"ZipCode",
		"QualitySystemCert",
		"ProductQualityCert",
		"MaunLicense",
		"QualifCert",
		"QualifCertLevel",
		"SafetyLicense",
		"TechServiceLic",
		"TJInNotify",
		"SpecIndustryCert",
		"LegalPerson",
		"CategoryCode",
		"CategoryName",
		"RegCapital",
		"Currency",
		"ContactName",
		"CompanyType",
		"SetupTime",
		"DepositBank",
		"BankAccount",
		"EMail",
		"BusinessScope",
		"BankCreditRating",
		"Mobile",
		"Telphone",
		"Fax",

		"CompanyTel",

		"QQ",

		"CompanyUrl",

		"SpecSupplier",

		"SpecTypeCode",

		"SpecTypeName",

		/*"WorkerTotal",
		"ContractNum ",
		"UniversityNum",
		"TechnicalNum",
		"AboveProfNum",
		"MiddleProfNum",
		"NationalRegNum",
		"NationalCertTotal",
		"DesignerTotal",
		"SkillerTotal",*/

		"Remark",

		"IsDelete",

		"CreateOn",

		"CreateUserId",

		"CreateBy",

		"ModifiedOn",

		"ModifiedUserId",

		"ModifiedBy",
		"LinkAddress",
		"LinkProvince",
		"LinkCity",
		"LinkStreet",
		"LinkHouseNo",
		"LinkZipCode",
		"HseTraining",
		"CredentialFlag",
		"SupplierCertificate",
		"PACNumber",
	}
	err := svc.UpdateEntityBytbl(OilSupplierName, id, &model, updateCols)
	if err == nil {
		if instyle != "" {
			svc.DBE.Exec("update OilSupplierCert set Instyle=" + instyle + " where SupplierId=" + id + " and SupplierTypeCode=" + typeCode + "")
		}
		errinfo.Message = "修改成功！"
		errinfo.Code = 0
		this.Data["json"] = &errinfo
		this.ServeJSON()
	} else {
		errinfo.Message = "修改失败！" + utils.AlertProcess(err.Error())
		errinfo.Code = -1
		this.Data["json"] = &errinfo
		this.ServeJSON()
	}
}

// @Title 添加
// @Description 新增年审
// @Success	200	{object} controllers.Request
// @router /add [post]
func (this *AnnualAuditController) AddEntity() {
	var model annualaudit.OilAnnualAudit
	var errInfo ErrorDataInfo
	var jsonBlob = this.Ctx.Input.RequestBody
	svc := annualaudit.GetOilAnnualAuditService(utils.DBE)
	//firstAudit := this.GetString("firstAudit")
	json.Unmarshal(jsonBlob, &model)
	where := "SupplierId = " + utils.ToStr(model.SupplierId) + " and SupplierTypeName = " + model.SupplierTypeName + " and (Status < 8 or Status in ('9','10'))"
	var auditEntity []annualaudit.OilAnnualAudit
	svc.GetEntitysByWhere(""+OilAnnualAuditName, where, &auditEntity)
	if len(auditEntity) >= 1 {
		errInfo.Message = "今年已提交年审，请勿重复提交！"
		errInfo.Code = -1
		this.Data["json"] = &errInfo
		this.ServeJSON()
		return
	}
	supWhere := "a.Id = " + utils.ToStr(model.SupplierId) + " and b.SupplierTypeCode = '" + model.SupplierTypeName + "' and (b.Status = '8' or b.Status = '11' "
	supSvc := supplier.GetOilSupplierService(utils.DBE)
	var list []supplier.OilSupplierView
	total := supSvc.GetMyPagingEntitiesWithOrderBytbl(OilSupplierName, OilSupplierCertName, 1, 1, "a.Id", true, &list, supWhere)
	if total == 0 {
		//errInfo.Message = "请先提交准入申请再提交年审！"
		errInfo.Message = "请先提交准入，准入申请通过后，才可申请年审！"
		errInfo.Code = -1
		this.Data["json"] = &errInfo
		this.ServeJSON()
		return
	}
	var supplierModel supplier.OilSupplierView
	supplierModel = list[0]
	if supplierModel.InFlag == "3" {
		errInfo.Message = "超过两年未年审，您已无法提交！"
		errInfo.Code = -1
		this.Data["json"] = &errInfo
		this.ServeJSON()
		return
	}
	applyTime := supplierModel.ApplyTime
	subTime := this.getTimeSub(applyTime, time.Now())
	leftTime := subTime - 3
	if subTime > 3 {
		errInfo.Message = "还不到年审时间！请" + utils.ToStr(leftTime) + "个月后再来申请"
		errInfo.Code = -3
		this.Data["json"] = &errInfo
		this.ServeJSON()
		return
	}
	model.AccessCardNo = supplierModel.AccessCardNo
	model.RecUnitId = supplierModel.RecUnitId
	model.CerId, _ = strconv.Atoi(supplierModel.CertId)
	model.ApplyTime = supplierModel.ApplyTime
	model.Status = "0"
	model.Step = 1
	model.BackReason = supplierModel.BackReason
	model.CreateOn = time.Now()
	model.CreateBy = this.User.Realname
	model.CreateUserId, _ = utils.StrTo(this.User.Id).Int()
	//添加一条年审记录
	_, err := svc.InsertEntityBytbl(""+OilAnnualAuditName, &model)
	if err == nil {
		//新增
		errInfo.Message = "添加成功！"
		errInfo.Code = 0
		errInfo.Item = model.Id
		this.Data["json"] = &errInfo
		this.ServeJSON()
	} else {
		errInfo.Message = "添加失败！" + utils.AlertProcess(err.Error())
		errInfo.Code = -1
		this.Data["json"] = &errInfo
		this.ServeJSON()
	}
}

func (this *AnnualAuditController) getTimeSub(t1, t2 time.Time) int {
	t1 = time.Date(t1.Year(), t1.Month(), t1.Day(), 0, 0, 0, 0, time.Local)
	t2 = time.Date(t2.Year(), t2.Month(), t2.Day(), 0, 0, 0, 0, time.Local)
	return int(t1.Sub(t2).Hours() / 24 / 30)
}

// @Title 提交审批
// @Description 提交审批
// @Success	200	{object} controllers.Request
// @router /addauditcomm [post]
func (this *AnnualAuditController) AddAuditEntity() {
	var model ComShenHeModel
	var errinfo ErrorDataInfo
	var jsonBlob = this.Ctx.Input.RequestBody
	svc := annualaudit.GetOilAnnualAuditService(utils.DBE)
	annualId := this.GetString("AnnualId")
	firstAudit := this.GetString("FirstAuditName")
	secondAudit := this.GetString("SecondAudit")
	thirdAudit := this.GetString("ThirdAudit")
	json.Unmarshal(jsonBlob, &model)

	var setting auditsetting.Base_OilAuditSetting
	var userlist []userRole.Base_User
	usvc := userRole.GetUserService(utils.DBE)
	where := ""
	if this.User.IsCompanyUser == 1 {
		if model.SupplierTypeName == "01" {
			where = "AuditStepCode='" + workflow.SUB_OFFICE_WZ + "'"
		} else if model.SupplierTypeName == "02" {
			where = "AuditStepCode='" + workflow.SUB_OFFICE_JS + "'"

		} else if model.SupplierTypeName == "03" {
			where = "AuditStepCode='" + workflow.SUB_OFFICE_JF + "'"
		}
		usvc.GetEntity(&setting, where)
		ids := usvc.GetUserIdsByRoleId(strconv.Itoa(setting.RoleId))
		tempstr := strings.Join(ids, ",")
		uids := strings.Replace(tempstr, "uid_", "", -1)
		uids = strings.Trim(uids, ",")
		if uids != "" {
			where := "Id in (" + uids + ")" + " and UnitId=" + firstAudit
			usvc.GetEntities(&userlist, where)
		}
		userIds := ""
		for _, tmpUser := range userlist {
			userIds += strconv.Itoa(tmpUser.Id) + ","
		}
		firstAudit = strings.Trim(userIds, ",")
	}

	//where := "CerId = " + utils.ToStr(model.SupplierId) + " and SupplierTypeName = " + model.SupplierTypeName
	var auditentity annualaudit.OilAnnualAudit
	svc.GetEntityById(annualId, &auditentity)
	historworkflowid := auditentity.WorkflowId
	svcActiviti := workflow.GetActivitiService(utils.DBE)
	statusint, _ := strconv.Atoi(auditentity.Status)
	var ActiComplete workflow.ActiCompleteVM
	var auditmodel annualaudit.OilAnnualAudit
	result := strconv.Itoa(this.User.IsCompanyUser)
	//重新工作流
	if statusint < 0 {
		businessKey := utils.ToStr(annualId) + "-" + strconv.Itoa(auditentity.AuditIndex)
		processInstanceId := svcActiviti.StartProcess2(workflow.OIL_AUDIT_APPLY, businessKey, this.User.Id, result, auditentity.SupplierTypeName, auditentity.SupplierName)
		ActiComplete.BusinessKey = businessKey
		auditmodel.WorkflowId = processInstanceId
		auditmodel.BusinessKey = businessKey
	} else {
		auditmodel.WorkflowId = auditentity.WorkflowId
		ActiComplete.BusinessKey = auditentity.BusinessKey
		auditmodel.BusinessKey = auditentity.BusinessKey

	}
	ActiComplete.ProcessKey = workflow.OIL_AUDIT_APPLY
	ActiComplete.UserNames = firstAudit
	ActiComplete.UserId = this.User.Id
	ActiComplete.Result = result
	ActiComplete.Remarks = model.Remark
	ActiComplete.CallbackUrl = ""

	//提交给二级单位初审
	receiveVal := svcActiviti.TaskComplete(ActiComplete)
	if statusint < 0 {
		// 存储审批历史
		var audithistoryentity audithistory.Base_AuditHistory
		audithistoryentity.EntityId, _ = strconv.Atoi(annualId)
		audithistoryentity.WorkflowId = historworkflowid
		audithistoryentity.Process = workflow.OIL_AUDIT_APPLY
		audithistoryentity.BusinessKey = auditentity.BusinessKey
		audithistoryentity.Type = model.SupplierTypeName
		audithistoryentity.BackStep = utils.ToStr(auditentity.Status)
		audithistoryentity.Index = auditentity.AuditIndex
		audithistoryentity.CreateOn = time.Now()
		audithistoryentity.CreateBy = this.User.Realname
		audithistoryentity.CreateUserId, _ = utils.StrTo(this.User.Id).Int()
		svc.InsertEntity(audithistoryentity)
	}
	if this.User.IsCompanyUser == 1 {
		auditmodel.Status = suppliercert.FEN_TRIAL_STATUS //二级单位分办
	} else {
		auditmodel.Status = suppliercert.FIRST_TRIAL_STATUS
	}
	auditmodel.FenbanAudit, _ = strconv.Atoi(firstAudit)
	auditmodel.FirstAudit, _ = strconv.Atoi(firstAudit)
	auditmodel.SecondAudit, _ = strconv.Atoi(secondAudit)
	auditmodel.ThirdAudit, _ = strconv.Atoi(thirdAudit)

	cols := []string{
		"Id",
		"WorkflowId",
		"FenbanAudit",
		"FirstAudit",
		"SecondAudit",
		"ThirdAudit",
		"Status",
		"BusinessKey",
	}
	if receiveVal == "true" {
		_, err := svc.UpdateEntityByIdCols(annualId, auditmodel, cols)
		if err == nil {
			//新增
			errinfo.Message = "提交成功！"
			errinfo.Code = 0
			errinfo.Item = auditmodel.Status
			this.Data["json"] = &errinfo
			this.ServeJSON()
		} else {
			errinfo.Message = "提交失败！" + utils.AlertProcess(err.Error())
			errinfo.Code = -1
			this.Data["json"] = &errinfo
			this.ServeJSON()
		}
	} else {
		errinfo.Message = "工作流异常，请联系管理员！"
		errinfo.Code = -1
		this.Data["json"] = &errinfo
		this.ServeJSON()
	}

}

// @Title 企业用户提交按钮  --启动工作流
// @Description 企业用户提交按钮
// @Success	200	{object} controllers.Request
// @router /company-audit/:id [post]
func (this *AnnualAuditController) CompanyAuditEntity() {
	annualId := this.Ctx.Input.Param(":id")
	unitId := this.GetString("UnitId")
	// typeCode := this.GetString("TypeCode")
	AuditRemark := this.GetString("AuditRemark")
	var errinfo ErrorDataInfo
	defer func() { //finally处理失败的异常
		if err := recover(); err != nil {
			errinfo.Message = err.(string)
			errinfo.Code = -1
			this.Data["json"] = &errinfo
			this.ServeJSON()
		} else {
			//返回正确结果
			errinfo.Message = "提交成功"
			errinfo.Code = 0
			this.Data["json"] = &errinfo
			this.ServeJSON()
		}
	}()

	if this.User.IsCompanyUser == 0 {
		// 0二级单位; 1企业用户
		panic("非企业用户，请用分办功能提交！")
	}

	//取出准入申请表
	srv := annualaudit.GetOilAnnualAuditService(utils.DBE)
	var annualEntity annualaudit.OilAnnualAudit
	srv.GetEntityById(annualId, &annualEntity)
	//srv.IsSupplierCertCanSubmit(strconv.Itoa(supplierCertEntity.Id), certId) TODO 参数检查

	if this.User.Realname != annualEntity.CreateBy {
		panic("请联系申请创建人:" + annualEntity.CreateBy + " 予以提交，或删除该申请后重新创建再提交！")
	}

	//取出企业主表
	supplierSvc := supplier.GetOilSupplierService(utils.DBE)
	var supplierEntity supplier.OilSupplier
	//检查是否可提交
	supplierSvc.GetEntityById(annualEntity.SupplierId, &supplierEntity)

	status, _ := strconv.Atoi(annualEntity.Status)
	if status > 0 {
		panic("工作流已经启动，请刷新重试！")
	}

	supplierCertSrv := suppliercert.GetOilSupplierCertService(utils.DBE)
	var supplierCertEntity suppliercert.OilSupplierCert
	supplierCertSrv.GetEntityById(annualEntity.CerId, &supplierCertEntity)
	stepCode := workflow.GetWorkFlowStepCode(supplierCertEntity.SupplierTypeCode) // TODO 年审的准入方式
	auditSettingService := auditsetting.GetOilAuditSettingService(utils.DBE)
	approverIds := auditSettingService.GetApproverIdsByStepCodeAndUnitId(stepCode, unitId)
	if approverIds == "" {
		panic("该分办单位未配置审批人")
	}

	svcActiviti := workflow.GetActivitiService(utils.DBE)
	//启动工作流
	businessKey := annualEntity.BusinessKey
	processInstanceId := annualEntity.WorkflowId
	// 如果被驳回，不再新启工作流
	if processInstanceId == "" {
		businessKey = annualId + "-" + strconv.Itoa(annualEntity.AuditIndex)
		processInstanceId = svcActiviti.StartProcess2(workflow.OIL_AUDIT_APPLY, businessKey, this.User.Id, "1", annualEntity.SupplierTypeName, supplierEntity.SupplierName)
		if len(processInstanceId) <= 0 {
			panic("工作流启动失败！")
		}
		annualEntity.AuditIndex += 1
	}
	// 将启动和工作流，选择的初审和复审人员保存下来
	cols := []string{
		"Id",
		"WorkflowId",
		"BusinessKey",
		"ProcessKey",
		"CommitComId",
		"AuditIndex",
	}
	annualEntity.ProcessKey = workflow.OIL_AUDIT_APPLY
	annualEntity.BusinessKey = businessKey
	annualEntity.WorkflowId = processInstanceId
	annualEntity.CommitComId = unitId
	srv.UpdateEntityByIdCols(annualId, annualEntity, cols)

	var ActiComplete workflow.ActiCompleteVM
	ActiComplete.ProcessKey = workflow.OIL_AUDIT_APPLY
	ActiComplete.BusinessKey = businessKey
	ActiComplete.UserId = this.User.Id
	ActiComplete.Result = "1" //提交给二级单位分办
	ActiComplete.Remarks = AuditRemark
	ActiComplete.CallbackUrl = utils.Cfg.MustValue("workflow", "callbackHost")

	receiveVal := svcActiviti.TaskComplete(ActiComplete)
	if receiveVal != "true" {
		log.Println("工作流异常, 业务ID："+annualEntity.BusinessKey+"， 流程ID："+annualEntity.WorkflowId, " 工作流传参: ", ActiComplete, receiveVal)
		panic("任务已审批，请刷新！")
	}

	// 入库成功 记录快照
	supplierLogService := supplierlog.GetSupplierLogService(utils.DBE)
	sourceId, _ := strconv.Atoi(annualId)
	supplierLogService.SaveSupplierLogForAnnual(annualEntity.SupplierId, sourceId) // 年审
}

// @Title 二级单位分办提交审批
// @Description 提交审批
// @Success	200	{object} controllers.Request
// @router /unit-audit/:id [post]
func (this *AnnualAuditController) SeparateUnitSubmitAuditEntity() {
	annualId := this.Ctx.Input.Param(":id")
	firstAudit := this.GetString("firstAudit")
	secondAudit := this.GetString("SecondAudit")
	auditRemark := this.GetString("AuditRemark")

	userId := this.User.Id
	var baseUserInfo userRole.Base_User
	userService := userRole.GetUserService(utils.DBE)
	userService.GetEntityById(userId, &baseUserInfo)
	unitId := baseUserInfo.UnitId

	var errinfo ErrorDataInfo
	defer func() { //finally处理失败的异常
		if err := recover(); err != nil {
			errinfo.Message = err.(string)
			errinfo.Code = -1
			this.Data["json"] = &errinfo
			this.ServeJSON()
		} else {
			//返回正确结果
			errinfo.Message = "审核提交成功"
			errinfo.Code = 0
			this.Data["json"] = &errinfo
			this.ServeJSON()
		}
	}()

	if firstAudit == "" || secondAudit == "" {
		panic("请选择审批人")
	}

	svc := annualaudit.GetOilAnnualAuditService(utils.DBE)
	var auditEntity annualaudit.OilAnnualAudit
	svc.GetEntityById(annualId, &auditEntity)
	var supplierEntity supplier.OilSupplier
	svc.GetEntityById(auditEntity.SupplierId, &supplierEntity)

	if this.User.Realname != auditEntity.CreateBy {
		panic("请联系申请创建人:" + auditEntity.CreateBy + " 予以提交，或删除该申请后重新创建再提交！")
	}

	svcActiviti := workflow.GetActivitiService(utils.DBE)
	//启动工作流
	businessKey := auditEntity.BusinessKey
	processInstanceId := auditEntity.WorkflowId
	// 如果被驳回，不再新启工作流
	if processInstanceId == "" {
		businessKey = annualId + "-" + strconv.Itoa(auditEntity.AuditIndex)
		processInstanceId = svcActiviti.StartProcess2(workflow.OIL_AUDIT_APPLY, businessKey, this.User.Id, "1", auditEntity.SupplierTypeName, supplierEntity.SupplierName)
		if len(processInstanceId) <= 0 {
			panic("工作流启动失败！")
		}
		auditEntity.AuditIndex += 1
	}

	// 将启动和工作流，选择的初审和复审人员保存下来
	cols := []string{
		"Id",
		"FirstAudit",
		"SecondAudit",
		"WorkflowId",
		"BusinessKey",
		"ProcessKey",
		"CommitComId",
		"AuditIndex",
	}
	auditEntity.ProcessKey = workflow.OIL_AUDIT_APPLY
	auditEntity.BusinessKey = businessKey
	auditEntity.WorkflowId = processInstanceId
	auditEntity.FirstAudit, _ = strconv.Atoi(firstAudit)
	auditEntity.SecondAudit, _ = strconv.Atoi(secondAudit)
	auditEntity.CommitComId = strconv.Itoa(unitId)
	svc.UpdateEntityByIdCols(annualId, auditEntity, cols)

	var ActiComplete workflow.ActiCompleteVM
	ActiComplete.ProcessKey = workflow.OIL_AUDIT_APPLY
	ActiComplete.BusinessKey = auditEntity.BusinessKey
	ActiComplete.UserId = this.User.Id // 当前审批操作人员
	//ActiComplete.UserNames = secondAudit // 当前审批操作人员
	ActiComplete.Result = "2" //分办提交给二级单位初审
	ActiComplete.Remarks = auditRemark
	ActiComplete.CallbackUrl = utils.Cfg.MustValue("workflow", "callbackHost")
	receiveVal := svcActiviti.TaskComplete(ActiComplete)
	if receiveVal != "true" {
		log.Println("工作流异常, 业务ID："+auditEntity.BusinessKey+"， 流程ID："+auditEntity.WorkflowId, " 工作流传参: ", ActiComplete, receiveVal)
		panic("任务已审批，请刷新！")
	}

	// 入库成功 记录快照
	supplierLogService := supplierlog.GetSupplierLogService(utils.DBE)
	sourceId, _ := strconv.Atoi(annualId)
	supplierLogService.SaveSupplierLogForAnnual(auditEntity.SupplierId, sourceId) // 年审
}

// @Title 二级单位分办 --审批
// @Description 二级分办
// @Success	200	{object} controllers.Request
// @router /separate-audit/:id [post]
func (this *AnnualAuditController) SeparateAuditEntity() {
	annualId := this.Ctx.Input.Param(":id")
	Result := this.GetString("Result")
	firstAudit := this.GetString("FirstAudit")
	secondAudit := this.GetString("SecondAudit")
	// typeCode := this.GetString("TypeCode")
	AuditRemark := this.GetString("AuditRemark")

	var errinfo ErrorDataInfo
	defer func() { //finally处理失败的异常
		if err := recover(); err != nil {
			errinfo.Message = err.(string)
			errinfo.Code = -1
			this.Data["json"] = &errinfo
			this.ServeJSON()
		} else {
			//返回正确结果
			errinfo.Message = "审核提交成功"
			errinfo.Code = 0
			this.Data["json"] = &errinfo
			this.ServeJSON()
		}
	}()

	// 取出准入表信息
	srv := annualaudit.GetOilAnnualAuditService(utils.DBE)
	var annualEntity annualaudit.OilAnnualAudit
	srv.GetEntityById(annualId, &annualEntity)
	if Result == "1" {
		if firstAudit == "" || secondAudit == "" {
			panic("请选择审批人")
		}
		// 将选择的初审和复审人员保存下来
		cols := []string{
			"FirstAudit",
			"SecondAudit",
			"thirdAudit",
		}
		annualEntity.FirstAudit, _ = strconv.Atoi(firstAudit)
		annualEntity.SecondAudit, _ = strconv.Atoi(secondAudit)
		srv.UpdateEntityByIdCols(annualId, annualEntity, cols)
	}

	svcActiviti := workflow.GetActivitiService(utils.DBE)
	var ActiComplete workflow.ActiCompleteVM
	ActiComplete.ProcessKey = workflow.OIL_AUDIT_APPLY
	ActiComplete.BusinessKey = annualEntity.BusinessKey
	ActiComplete.UserId = this.User.Id // 审批人员
	// ActiComplete.UserNames = secondAudit // 初审人员
	ActiComplete.Result = Result //分办完成后只向前走
	ActiComplete.Remarks = AuditRemark
	ActiComplete.CallbackUrl = utils.Cfg.MustValue("workflow", "callbackHost")
	receiveVal := svcActiviti.TaskComplete(ActiComplete)
	if receiveVal != "true" {
		log.Print("工作流异常, 业务ID："+annualEntity.BusinessKey+"， 流程ID："+annualEntity.WorkflowId, " 工作流传参: ", ActiComplete, receiveVal)
		panic("任务已审批，请刷新！")
	}
}

// @Title 分办之后的各级审批  --审批 包含：二级单位初审、复审、企业法规处审核
// @Description 分办之后的各级审批
// @Success	200	{object} controllers.Request
// @router /common-audit/:id [post]
func (this *AnnualAuditController) CommonAuditEntity() {
	annualId := this.Ctx.Input.Param(":id")
	result := this.GetString("result")
	AuditRemark := this.GetString("AuditRemark")

	var errinfo ErrorDataInfo
	defer func() { //finally处理失败的异常
		if err := recover(); err != nil {
			errinfo.Message = err.(string)
			errinfo.Code = -1
			this.Data["json"] = &errinfo
			this.ServeJSON()
		} else {
			//返回正确结果
			errinfo.Message = "审核提交成功"
			errinfo.Code = 0
			this.Data["json"] = &errinfo
			this.ServeJSON()
		}
	}()

	//取出准入表信息
	svc := annualaudit.GetOilAnnualAuditService(utils.DBE)
	var annualEntity annualaudit.OilAnnualAudit
	svc.GetEntityById(annualId, &annualEntity)

	svcActiviti := workflow.GetActivitiService(utils.DBE)
	var ActiComplete workflow.ActiCompleteVM
	ActiComplete.ProcessKey = workflow.OIL_AUDIT_APPLY
	ActiComplete.BusinessKey = annualEntity.BusinessKey
	ActiComplete.UserId = this.User.Id //审批人员
	ActiComplete.Result = result       //前台审批[同意、不同意]
	ActiComplete.Remarks = AuditRemark
	ActiComplete.CallbackUrl = utils.Cfg.MustValue("workflow", "callbackHost")
	receiveVal := svcActiviti.TaskComplete(ActiComplete)
	if receiveVal != "true" {
		log.Println("工作流异常, 业务ID："+annualEntity.BusinessKey+"， 流程ID："+annualEntity.WorkflowId, " 工作流传参: ", ActiComplete, receiveVal)
		panic("任务已审批，请刷新！")
	}
}

// @Title 确认是否入库
// @Description 确认是否入库
// @Success	200	{object} controllers.Request
// @router /update-is-storage/:id [post]
func (this *AnnualAuditController) UpdateIsStorage() {
	id := this.Ctx.Input.Param(":id")
	status := this.GetString("Status")
	//PACNumber := this.GetString("PACNumber")
	//SupplierId := this.GetString("SupplierId")
	var errinfo ErrorInfo
	if id == "" {
		errinfo.Message = "操作失败！请求信息不完整"
		errinfo.Code = -2
		this.Data["json"] = &errinfo
		this.ServeJSON()
		return
	}

	defer func() { //finally处理失败的异常
		if err := recover(); err != nil {
			errinfo.Message = err.(string)
			errinfo.Code = -1
			this.Data["json"] = &errinfo
			this.ServeJSON()
		} else {
			//返回正确结果
			if status == "1" {
				errinfo.Message = "入库成功"
			} else {
				errinfo.Message = "退回成功"
			}
			errinfo.Code = 0
			this.Data["json"] = &errinfo
			this.ServeJSON()
		}
	}()

	var annualEntity annualaudit.OilAnnualAudit
	annualSrv := annualaudit.GetOilAnnualAuditService(utils.DBE)
	annualSrv.GetEntityById(id, &annualEntity)

	//var supplierEntity supplier.OilSupplier
	//srv := supplier.GetOilSupplierService(utils.DBE)
	//srv.GetEntityById(SupplierId, &supplierEntity)
	//supplierEntity.PACNumber = PACNumber
	//srvCols := []string{"PACNumber"}
	//srv.UpdateEntityByIdCols(SupplierId, &supplierEntity, srvCols)

	AuditRemark := ""
	fmt.Println("年审审批入库传入状态：", status)
	if status == "1" {
		AuditRemark = "审批通过已入库。"
	} else {
		status = "0"
		AuditRemark = "入库退回。"
	}

	svcActiviti := workflow.GetActivitiService(utils.DBE)
	var ActiComplete workflow.ActiCompleteVM
	ActiComplete.ProcessKey = workflow.OIL_AUDIT_APPLY
	ActiComplete.BusinessKey = annualEntity.BusinessKey
	ActiComplete.UserId = this.User.Id //审批人员
	ActiComplete.Result = status       //前台审批[同意、不同意]
	ActiComplete.Remarks = AuditRemark
	ActiComplete.CallbackUrl = utils.Cfg.MustValue("workflow", "callbackHost")
	receiveVal := svcActiviti.TaskComplete(ActiComplete)
	if receiveVal != "true" {
		log.Println("工作流异常, 业务ID："+annualEntity.BusinessKey+"， 流程ID："+annualEntity.WorkflowId, " 工作流传参: ", ActiComplete, receiveVal)
		panic("任务已审批，请刷新！")
	}

}

// @Title 删除单条信息
// @Description
// @Success 200 {object} ErrorInfo
// @Failure 403 :id 为空
// @router /delete/:Id [delete]
func (this *AnnualAuditController) DeleteEntity() {
	Id := this.Ctx.Input.Param(":Id")
	var errinfo ErrorInfo
	if Id == "" {
		errinfo.Message = "操作失败！请求信息不完整"
		errinfo.Code = -2
		this.Data["json"] = &errinfo
		this.ServeJSON()
		return
	}
	var model annualaudit.OilAnnualAudit
	var entityempty annualaudit.OilAnnualAudit
	svc := annualaudit.GetOilAnnualAuditService(utils.DBE)
	opdesc := "删除-" + Id
	// 删除变更的资质
	wherefile := "ParentId=" + Id
	svc.DeleteEntityBytbl(OilAnnualChangeDetailName, wherefile)

	err := svc.DeleteOperationAndWriteLogBytbl(""+OilAnnualAuditName, BaseOperationLogName, Id, &model, &entityempty, utils.ToStr(this.User.Id), this.User.Username, opdesc, "", "钻井日报")
	if err == nil {
		activitiService := workflow.GetActivitiService(utils.DBE)
		var deleteProcessVM workflow.DeleteProcessVM
		if model.WorkflowId != "" && model.WorkflowId != "0" {
			deleteProcessVM.ProcessInstanceId = model.WorkflowId
			deleteProcessVM.DeleteReason = "年审申请审批未通过后，被申请人删除"
			activitiService.DeleteComplete(deleteProcessVM)
		}

		errinfo.Message = "删除成功"
		errinfo.Code = 0
		this.Data["json"] = &errinfo
		this.ServeJSON()
	} else {
		errinfo.Message = "删除失败！" + utils.AlertProcess(err.Error())
		errinfo.Code = -1
		this.Data["json"] = &errinfo
		this.ServeJSON()
	}
}

// @Title 审核
// @Description 审核
// @Success	200	{object} controllers.Request
// @router /auditcallback [get]
func (this *AnnualAuditController) AuditCallback() {
	result := this.GetString("ret")
	bussinsid := this.GetString("busid")
	status := this.GetString("status")
	annualId := this.GetString("annualId")
	svc := annualaudit.GetOilAnnualAuditService(utils.DBE)
	var entityempty annualaudit.OilAnnualAudit
	var err error
	var errinfo ErrorInfo
	var cols []string = []string{"Status"}
	entityempty.Status = status
	err = svc.UpdateEntityBytbl(OilAnnualAuditName, annualId, &entityempty, cols)
	if err != nil {
		errinfo.Message = "审核错误！"
		errinfo.Code = -1
		this.Data["json"] = &errinfo
		this.ServeJSON()
	}
	fmt.Println(result, status, annualId, bussinsid)
}

// @Title 审核
// @Description 审核
// @Success	200	{object} controllers.Request
// @router /auditfirst [put]
func (this *AnnualAuditController) AnnualAudit() {
	svc := annualaudit.GetOilAnnualAuditService(utils.DBE)
	var jsonblob = this.Ctx.Input.RequestBody
	var dataother ShenHeModel
	var errinfo ErrorInfo
	json.Unmarshal(jsonblob, &dataother)
	ProfAudit := this.GetString("ProfAudit")
	firstAudit := this.GetString("FirstAudit")
	secondAudit := this.GetString("SecondAudit")
	thirdAudit := this.GetString("ThirdAudit")
	var list annualaudit.OilAnnualAudit
	where := " Id = '" + strconv.Itoa(dataother.AnnualId) + "'"
	svc.GetEntityByWhere(""+OilAnnualAuditName, where, &list)

	var supplierEntity supplier.OilSupplier
	wheresup := "Id=" + strconv.Itoa(list.SupplierId)
	svc.GetEntity(&supplierEntity, wheresup)

	var certEntity suppliercert.OilSupplierCert
	wherecert := "Id=" + strconv.Itoa(list.CerId)
	svc.GetEntity(&certEntity, wherecert)

	svcActiviti := workflow.GetActivitiService(utils.DBE)
	//审核状态判断进行的操作
	step := 2
	status := ""
	backstatus := "0"
	var userIds string
	if list.Status == suppliercert.FEN_TRIAL_STATUS {
		userIds = firstAudit
		status = suppliercert.FIRST_TRIAL_STATUS
		step = 2
		backstatus = suppliercert.NO_FEN_TRIAL_STATUS
		if dataother.SuccessStatus == 1 {
			list.FirstAudit, _ = strconv.Atoi(firstAudit)
			list.SecondAudit, _ = strconv.Atoi(secondAudit)
			list.ThirdAudit, _ = strconv.Atoi(thirdAudit)
			cols := []string{
				"FirstAudit",
				"SecondAudit",
				"ThirdAudit",
			}
			svc.UpdateEntityByIdCols(dataother.AnnualId, list, cols)
		}
	}
	if list.Status == suppliercert.DRAFT_STATUS && this.User.IsCompanyUser == 1 {
		userIds = utils.ToStr(list.SecondAudit)
		status = suppliercert.SECOND_TRIAL_STATUS
		step = 2
		backstatus = suppliercert.NOPASS_STATUS
	}
	if list.Status == suppliercert.FIRST_TRIAL_STATUS {
		userIds = utils.ToStr(list.SecondAudit)
		status = suppliercert.SECOND_TRIAL_STATUS
		step = 2
		backstatus = suppliercert.NOPASS_STATUS
	} else if list.Status == suppliercert.SECOND_TRIAL_STATUS {
		status = suppliercert.CENT_AUDIT_STATUS
		step = 2
		backstatus = suppliercert.NO_SECOND_TRIAL_STATUS

		paramSvc := baseparameter.GetBaseparameterService(utils.DBE)
		topid := paramSvc.GetBaseparameterMessage("", "paramset", "CENT_AUDIT")

		var userlist []userRole.Base_User
		var setting auditsetting.Base_OilAuditSetting
		usvc := userRole.GetUserService(utils.DBE)
		where := "AuditStepCode='" + workflow.PROF_REGULATION + "'"
		usvc.GetEntity(&setting, where)

		ids := usvc.GetUserIdsByRoleId(strconv.Itoa(setting.RoleId))
		tempstr := strings.Join(ids, ",")
		uids := strings.Replace(tempstr, "uid_", "", -1)
		uids = strings.Trim(uids, ",")
		if uids != "" {
			where := "Id in (" + uids + ")" + " and UnitId=" + topid
			usvc.GetEntities(&userlist, where)
		}
		for _, tmpUser := range userlist {
			userIds += strconv.Itoa(tmpUser.Id) + ","
		}

		userIds = strings.Trim(userIds, ",")
	} else if list.Status == suppliercert.THIRD_TRIAL_STATUS {
		userIds = ProfAudit
		status = suppliercert.PROF_AUDIT_STATUS
		step = 2
		backstatus = suppliercert.NO_THIRD_TRIAL_STATUS
	} else if list.Status == suppliercert.PROF_AUDIT_STATUS {
		status = suppliercert.PAYING_AUDIT_STATUS
		step = 3
		backstatus = suppliercert.NO_PROF_AUDIT_STATUS
	} else if list.Status == suppliercert.CENT_AUDIT_STATUS {
		status = suppliercert.PAYING_AUDIT_STATUS
		step = 3
		backstatus = suppliercert.NO_CENT_AUDIT_STATUS
	}
	var ActiComplete workflow.ActiCompleteVM
	ActiComplete.ProcessKey = workflow.OIL_AUDIT_APPLY
	ActiComplete.BusinessKey = list.BusinessKey
	ActiComplete.UserNames = userIds
	ActiComplete.UserId = this.User.Id
	ActiComplete.Remarks = dataother.AuditorRemark
	ActiComplete.CallbackUrl = ""
	if dataother.SuccessStatus == 1 {
		ActiComplete.Result = "1"
		receiveVal := svcActiviti.TaskComplete(ActiComplete)
		var auditmodel annualaudit.OilAnnualAudit
		auditmodel.Status = status
		oldaplydate := list.ApplyTime
		if list.Status == suppliercert.CENT_AUDIT_STATUS {

			if certEntity.InStyle == suppliercert.PINGSHEN || certEntity.InStyle == suppliercert.ERJIWUZI {
				var certmodel suppliercert.OilSupplierCert
				certmodel.AuditDate = time.Now()
				certcols := []string{
					"Id",
					//"ApplyTime",
					"AuditDate",
				}
				svc.UpdateEntityByIdCols(list.CerId, certmodel, certcols)
				paysvc := paymentinfo.GetPaymentService(utils.DBE)
				var Amount float64
				asvc := oilcostmanage.GetOilCostManageService(utils.DBE)
				Amount = asvc.GetAmount("ANNUAL", list.SupplierTypeName)
				var payinfo paymentinfo.OilPaymentInfo
				payinfo.SupplierId = list.SupplierId
				payinfo.SrcId = list.Id
				payinfo.SupplierCertId = list.CerId
				payinfo.USCCode = supplierEntity.CommercialNo
				payinfo.SupplierName = supplierEntity.SupplierName
				payinfo.PayType = "2"
				payinfo.IsPay = "0"
				payinfo.IsInvoice = "0"
				payinfo.Amount = strconv.FormatFloat(Amount, 'E', -1, 64)
				payinfo.CreateUserId = list.CreateUserId
				payinfo.CreateBy = list.CreateBy
				payinfo.CreateOn = time.Now()
				paysvc.InsertEntity(&payinfo)
				//发短信
				toMobile := supplierEntity.Mobile
				bFlag := ""
				if list.SupplierTypeName == "01" {
					bFlag = "物资类"
				} else if list.SupplierTypeName == "02" {
					bFlag = "基建类"
				} else {
					bFlag = "服务类"
				}
				msg := "您的" + bFlag + "年审审核通过，请及时确认信息并交费！"
				msgService := msg2.GetMsgService(utils.DBE)
				msgService.HandleMsg(toMobile, msg, "4-1", list.CreateBy, supplierEntity.ContactName, strconv.Itoa(list.CreateUserId), this.User.Username)
			} else {
				auditmodel.Status = suppliercert.ALL_PASE_STATUS
			}

			var qualdetail []annualaudit.OilAnnualChangeDetail
			where1 := "SupplierId = " + utils.ToStr(list.SupplierId) + " and ParentId=" + strconv.Itoa(list.Id)
			svc.GetEntities(&qualdetail, where1)
			if len(qualdetail) > 0 {
				for i := 0; i < len(qualdetail); i++ {
					var supfilemodel supplierfile.OilSupplierFile
					supfilemodel.FileName = qualdetail[i].FileName
					supfilemodel.FileUrl = qualdetail[i].FileUrl
					supfilemodel.EffectDate = qualdetail[i].EffectDate
					svc.UpdateEntityBytbl(OilSupplierFileName, qualdetail[i].FileId, &supfilemodel, []string{"FileName", "FileUrl", "EffectDate"})
				}
			}

			var infoitems []infochange.OilAnnualChangeItem
			where := "SupplierId = " + utils.ToStr(supplierEntity.Id) + " and InfoId = " + utils.ToStr(list.Id)
			svc.GetEntities(&infoitems, where)
			this.updatesupplier(OilSupplierName, supplierEntity.Id, infoitems)
		} else {
			auditmodel.ApplyTime = oldaplydate
		}
		auditmodel.Step = step
		if receiveVal == "true" {
			cols := []string{
				"Id",
				"Status",
				"Step",
				//"ApplyTime",
			}
			svc.UpdateEntityByIdCols(dataother.AnnualId, auditmodel, cols)

			//paysvc.AddPaymentinfo(list.SupplierId, list.Id, Amount, "2")
			errinfo.Message = "提交成功！"
			errinfo.Code = 0
			this.Data["json"] = &errinfo
			this.ServeJSON()
		} else {
			errinfo.Message = "工作流异常，请联系管理员！"
			errinfo.Code = -1
			this.Data["json"] = &errinfo
			this.ServeJSON()
			return
		}
	} else {
		ActiComplete.Result = "0"
		receiveVal := svcActiviti.TaskComplete(ActiComplete)
		if receiveVal == "true" {
			if list.Status == suppliercert.PROF_AUDIT_STATUS {
				list.Status = suppliercert.NO_CENT_AUDIT_STATUS
				list.AuditIndex = list.AuditIndex + 1
			} else {
				list.Status = backstatus
				list.AuditIndex = list.AuditIndex + 1
			}
			list.Step = 1
			cols := []string{
				"Status",
				"Step",
				"AuditIndex",
			}
			_, err := svc.UpdateEntityByIdCols(dataother.AnnualId, list, cols)

			toMobile := supplierEntity.Mobile
			bFlag := ""
			if list.SupplierTypeName == "01" {
				bFlag = "物资类"
			} else if list.SupplierTypeName == "02" {
				bFlag = "基建类"
			} else {
				bFlag = "服务类"
			}
			msg := "您的" + bFlag + "年审审核未通过，请及时查看！"
			msgService := msg2.GetMsgService(utils.DBE)
			msgService.HandleMsg(toMobile, msg, "4-1", list.CreateBy, supplierEntity.ContactName, strconv.Itoa(list.CreateUserId), this.User.Username)
			if err == nil {
				errinfo.Message = "提交成功！"
				errinfo.Code = 0
				this.Data["json"] = &errinfo
				this.ServeJSON()
			} else {
				errinfo.Message = "提交失败！"
				errinfo.Code = -1
				this.Data["json"] = &errinfo
				this.ServeJSON()
			}

		} else {
			errinfo.Message = "工作流异常，请联系管理员！"
			errinfo.Code = -1
			this.Data["json"] = &errinfo
			this.ServeJSON()
			return
		}
	}
}

// @Title 获取实体
// @Description 获取实体
// @Success 200 {object} supplier.OilSupplier
// @router /getchangelist/:id [get]
func (this *AnnualAuditController) GetChangeEntity() {
	Id := this.Ctx.Input.Param(":id")
	InfoId := this.GetString("InfomainId")
	var models [2]supplier.OilSupplier
	var model supplier.OilSupplier
	var enumModel supplier.OilSupplier
	svc := supplier.GetOilSupplierService(utils.DBE)
	svc.GetEntityByIdBytbl(OilSupplierName, Id, &model)
	models[0] = model

	var infoitems []infochange.OilAnnualChangeItem
	where := " SupplierId = " + Id + " and InfoId =" + InfoId
	where = where + " and ChangeStatus = 0"
	svc.GetEntitysByWhere(OilAnnualChangeItemName, where, &infoitems)
	tmpModel := &model
	enumModel = *tmpModel
	immumodel := reflect.ValueOf(&enumModel)
	elem := immumodel.Elem()
	if len(infoitems) == 0 {
		models[1] = enumModel
		this.Data["json"] = &models
		this.ServeJSON()
		return
	} else {
		for _, info := range infoitems {
			fmt.Println(info.SelectItem)
			fmt.Println(";;;;;;;;;", elem.FieldByName(info.SelectItem).Type().String())
			if elem.FieldByName(info.SelectItem).Type().String() == "int64" {
				intchangeinfo, _ := strconv.ParseInt(info.ChangeInfo, 10, 64)
				elem.FieldByName(info.SelectItem).SetInt(intchangeinfo)
			} else if elem.FieldByName(info.SelectItem).Type().String() == "float64" {
				floatchangeinfo, _ := strconv.ParseFloat(info.ChangeInfo, 64)
				elem.FieldByName(info.SelectItem).SetFloat(floatchangeinfo)
			} else if elem.FieldByName(info.SelectItem).Type().String() == "time.Time" {
				t, _ := time.Parse("2006-01-02", info.ChangeInfo[0:10])
				elem.FieldByName(info.SelectItem).Set(reflect.ValueOf(t))
			} else {
				elem.FieldByName(info.SelectItem).SetString(info.ChangeInfo)
			}
		}
		models[1] = enumModel
		this.Data["json"] = &models
		this.ServeJSON()
	}
}

// @Title 添加
// @Description 新增
// @Success	200	{object} controllers.Request
// @router /addinfochangeitemch [post]
func (this *AnnualAuditController) AddInfoChangeItemCh() {
	var model InfoChangeItemsAll
	var jsonBlob = this.Ctx.Input.RequestBody
	svc := infochange.GetInfoChangeService(utils.DBE)
	json.Unmarshal(jsonBlob, &model)
	var err error
	where := " SupplierId = " + model.SupplierId
	where = where + " and InfoId = " + model.MInfoId

	var deleteEntity infochange.OilAnnualChangeItem
	delMainId, _ := strconv.Atoi(model.MInfoId)
	deleteEntity.InfoId = delMainId
	svc.DBE.Delete(deleteEntity)

	var infoitementitys []infochange.OilAnnualChangeItem
	for i := 0; i < len(model.InfochangeForm); i++ {
		var infoitementity infochange.OilAnnualChangeItem
		infoitementity.SelectItem = model.InfochangeForm[i].SelectItem
		infoitementity.SelectItemName = model.InfochangeForm[i].SelectItemName
		infoitementity.ChangeInfo = model.InfochangeForm[i].ChangeInfo
		infoitementity.BeChangeInfo = model.InfochangeForm[i].BeChangeInfo
		infoitementity.ChangeStatus = 0
		infoitementity.SupplierId, _ = strconv.Atoi(model.SupplierId)
		infoitementity.InfoId, _ = strconv.Atoi(model.MInfoId)
		infoitementity.CreateOn = time.Now()
		infoitementity.CreateBy = this.User.Realname
		infoitementity.CreateUserId, _ = utils.StrTo(this.User.Id).Int()
		infoitementitys = append(infoitementitys, infoitementity)
	}
	_, err = svc.InsertEntityBytbl(""+OilAnnualChangeItemName, &infoitementitys)

	var errinfo ErrorDataInfo
	if err == nil {
		//新增
		errinfo.Message = "添加成功！"
		errinfo.Code = 0
		//errinfo.Item = model.Id
		this.Data["json"] = &errinfo
		this.ServeJSON()
	} else {
		errinfo.Message = "添加失败！" + utils.AlertProcess(err.Error())
		errinfo.Code = -1
		this.Data["json"] = &errinfo
		this.ServeJSON()
	}
}

// @Title 获取变更项
// @Description 获取实体
// @Success 200 {object} annualaudit.OilAnnualAudit
// @router /auditget/:id [get]
func (this *AnnualAuditController) GetEntityThen() {
	InfoId := this.Ctx.Input.Param(":id")
	var model []infochange.OilAnnualChangeItem
	svc := infochange.GetInfoChangeService(utils.DBE)
	where := " InfoId = " + InfoId
	svc.GetEntitysByWhere(OilAnnualChangeItemName, where, &model)
	var datainfo DataInfo
	datainfo.Items = model
	this.Data["json"] = &datainfo
	this.ServeJSON()
}

//更新供方信息表
func (this *AnnualAuditController) updatesupplier(supname string, suppid int, infoitems []infochange.OilAnnualChangeItem) error {
	svc := infochange.GetInfoChangeService(utils.DBE)
	var err error
	if len(infoitems) > 0 {
		for i := 0; i < len(infoitems); i++ {
			//var cols []string
			//cols = append(cols, infoitems[i].SelectItem)
			where := " Id = " + utils.ToStr(suppid)
			var sql string
			sql = `UPDATE ` + supname + ` set ` + infoitems[i].SelectItem + ` = '` + infoitems[i].ChangeInfo + `' where ` + where
			_, err = svc.DBE.Exec(sql)
			//err = svc.UpdateEntityBytbl(OilSupplierName, suppid, &supmodel, cols)
		}
	}

	return err
}

// @Title 资质文件
// @Description get user by token
// @Success 200 {object} models.Userblood
// @router /filelist [get]
func (this *AnnualAuditController) FileList() {
	page := this.GetPageInfoForm()
	var list []qualchange.OilQualChangeDetail1
	svc := qualchange.GetQualChangeService(utils.DBE)
	where := " 1=1 and a.IsDelete = 0"
	orderby := "a.SupplierTypeCode"
	asc := true
	Order := this.GetString("Order")
	Prop := this.GetString("Prop")
	if Order != "" && Prop != "" {
		orderby = Prop
		if Order == "asc" {
			asc = true
		}
	}
	SupplierId := this.GetString("SupplierId")
	MInfoId := this.GetString("MInfoId")
	if SupplierId != "" {
		where = where + " and a.SupplierId = '" + SupplierId + "'"
	}
	SupplierTypeCode := this.GetString("SupplierTypeCode")
	if SupplierTypeCode != "" {
		where = where + " and a.SupplierTypeCode in ( '000', '" + SupplierTypeCode + "')"
	}
	var total int64
	AuditStatus := this.GetString("Status")
	if AuditStatus == "8" {
		total = svc.GetQualPagingEntitiesStatus(OilSupplierFileName, OilAnnualChangeDetailName, page.CurrentPage, page.Size, orderby, asc, &list, where, MInfoId)
	} else {
		total = svc.GetQualPagingEntities(OilSupplierFileName, OilAnnualChangeDetailName, page.CurrentPage, page.Size, orderby, asc, &list, where, MInfoId)
	}
	var datainfo DataInfo
	datainfo.Items = list
	datainfo.CurrentItemCount = total
	this.Data["json"] = &datainfo
	this.ServeJSON()
}

// @Title 添加资金
// @Description 添加资金
// @Success	200	{object}
// @router /addqualchange/:id [post]
func (this *AnnualAuditController) AddQualChange() {
	id := this.Ctx.Input.Param(":id")
	var errinfo ErrorInfo
	if id == "" {
		errinfo.Message = "操作失败！请求信息不完整"
		errinfo.Code = -2
		this.Data["json"] = &errinfo
		this.ServeJSON()
		return
	}
	var model annualaudit.OilAnnualChangeDetail
	var jsonblob = this.Ctx.Input.RequestBody
	json.Unmarshal(jsonblob, &model)

	svc := qualchange.GetQualChangeService(utils.DBE)

	var supplierfile supplierfile.OilSupplierFile
	where := "SupplierId = '" + strconv.Itoa(model.SupplierId) + "' and NeedFileType='" + model.NeedFileType + "'"
	has := svc.GetEntity(&supplierfile, where)

	var tableHeader tableheader.BaseTableheader
	where1 := "Name = '" + model.NeedFileType + "'"
	svc.GetEntityByWhere(BaseTableHeader, where1, &tableHeader)

	if has {
		errinfo.Message = "操作失败！该资质已添加"
		errinfo.Code = -1
		this.Data["json"] = &errinfo
		this.ServeJSON()
		return
	}

	supplierfile.SupplierId = model.SupplierId
	supplierfile.SupplierTypeCode = model.SupplierTypeCode
	supplierfile.IsManuf = tableHeader.IsManuf
	supplierfile.NeedFileType = model.NeedFileType
	supplierfile.FileType = 1
	supplierfile.SupType = 4
	supplierfile.CreateOn = time.Now()
	supplierfile.CreateUserId, _ = strconv.Atoi(this.User.Id)
	supplierfile.CreateBy = this.User.Realname
	supplierfile.FileUrl = strings.Trim(model.FileUrl, "$")
	supplierfile.FileName = strings.Trim(model.FileName, "$")
	supplierfile.EffectDate = model.EffectDate
	supplierfile.OtherRemark = model.Remark

	svc.InsertEntity(&supplierfile)

	model.ParentId, _ = strconv.Atoi(id)
	model.FileId = supplierfile.Id
	model.FileUrl = strings.Trim(model.FileUrl, "$")
	model.FileName = strings.Trim(model.FileName, "$")

	var err error
	var qualdetaimodel []annualaudit.OilAnnualChangeDetail

	qdwhere := " SupplierId = " + utils.ToStr(model.SupplierId) + " and FileId = " + utils.ToStr(supplierfile.Id) + " and ParentId=" + id
	svc.GetEntitysByWhere(OilAnnualChangeDetailName, qdwhere, &qualdetaimodel)
	if len(qualdetaimodel) == 0 {
		model.CreateOn = time.Now()
		model.CreateBy = this.User.Realname
		model.CreateUserId, _ = utils.StrTo(this.User.Id).Int()
		_, err = svc.InsertEntityBytbl(OilAnnualChangeDetailName, &model)
	} else {
		err = svc.UpdateEntityBywheretbl(OilAnnualChangeDetailName, &model, []string{"OldEffectDate", "FileUrl", "FileName", "OtherRemark"}, qdwhere)
	}

	if err == nil {
		errinfo.Message = "操作成功！"
		errinfo.Code = 0
		this.Data["json"] = &errinfo
		this.ServeJSON()
	} else {
		errinfo.Message = "操作失败！" + utils.AlertProcess(err.Error())
		errinfo.Code = -1
		this.Data["json"] = &errinfo
		this.ServeJSON()
	}
}

// @Title 资质文件变更上传
// @Description 更新文件上传
// @Param	id	path	string	true
// @Success	200	{object}
// @router /editqualchange/:id [put]
func (this *AnnualAuditController) EditQualChange() {
	id := this.Ctx.Input.Param(":id")
	var errinfo ErrorInfo
	if id == "" {
		errinfo.Message = "操作失败！请求信息不完整"
		errinfo.Code = -2
		this.Data["json"] = &errinfo
		this.ServeJSON()
		return
	}
	var model annualaudit.OilAnnualChangeDetail
	var jsonblob = this.Ctx.Input.RequestBody
	svc := qualchange.GetQualChangeService(utils.DBE)
	json.Unmarshal(jsonblob, &model)
	model.FileUrl = strings.Trim(model.FileUrl, "$")
	model.FileName = strings.Trim(model.FileName, "$")
	model.OldFileUrl = strings.Trim(model.OldFileUrl, "$")
	model.OldFileName = strings.Trim(model.OldFileName, "$")

	var supplierfile supplierfile.OilSupplierFile
	svc.GetEntityByIdBytbl(OilSupplierFileName, model.Id, &supplierfile)
	if supplierfile.FileUrl == "" {
		//区别 更新前和更新后文件
		supplierfile.FileUrl = strings.Trim(model.FileUrl, "$")
		supplierfile.FileName = strings.Trim(model.FileName, "$")
		supplierfile.EffectDate = model.EffectDate
	}
	supplierfile.ModifiedOn = time.Now()
	supplierfile.ModifiedUserId, _ = strconv.Atoi(this.User.Id)
	supplierfile.ModifiedBy = this.User.Realname
	supplierfile.OtherRemark = model.Remark
	svc.UpdateEntityBywheretbl(OilSupplierFileName, &supplierfile, []string{"EffectDate", "FileUrl", "FileName", "ModifiedOn", "ModifiedUserId", "ModifiedBy", "OtherRemark"}, "Id = "+strconv.Itoa(model.Id))

	var err error
	var entity annualaudit.OilAnnualChangeDetail
	var qualdetaimodel []annualaudit.OilAnnualChangeDetail
	var mainentirt qualchange.OilQualChangeMain
	var qualmain []qualchange.OilQualChangeMain
	qmwhere := " SupplierId = " + utils.ToStr(model.SupplierId)
	svc.GetEntitysByWhere(OilQualChangeMainName, qmwhere, &qualmain)
	mainentirt.Status = "0"
	mainentirt.Step = 1
	err = svc.UpdateEntityBywheretbl(OilQualChangeMainName, &mainentirt, []string{"SupplierCertId", "Status", "Step"}, qmwhere)

	qdwhere := " SupplierId = " + utils.ToStr(model.SupplierId) + " and FileId = " + utils.ToStr(model.Id) + " and ParentId=" + id
	svc.GetEntitysByWhere(OilAnnualChangeDetailName, qdwhere, &qualdetaimodel)
	entity = model
	entity.Id = 0
	entity.ParentId, _ = strconv.Atoi(id)
	entity.FileId = model.Id
	if len(qualdetaimodel) == 0 {
		entity.CreateOn = time.Now()
		entity.CreateBy = this.User.Realname
		entity.CreateUserId, _ = utils.StrTo(this.User.Id).Int()
		_, err = svc.InsertEntityBytbl(OilAnnualChangeDetailName, &entity)
	} else {
		err = svc.UpdateEntityBywheretbl(OilAnnualChangeDetailName, &entity, []string{"EffectDate", "FileUrl", "FileName", "OtherRemark"}, qdwhere)
	}

	if err == nil {
		errinfo.Message = "操作成功！"
		errinfo.Code = 0
		this.Data["json"] = &errinfo
		this.ServeJSON()
	} else {
		errinfo.Message = "操作失败！" + utils.AlertProcess(err.Error())
		errinfo.Code = -1
		this.Data["json"] = &errinfo
		this.ServeJSON()
	}
}

// @Title 删除新上传的资质
// @Description
// @Success 200 {object} ErrorInfo
// @Failure 403 :id 为空
// @router /deletenewfile/:Id [delete]
func (this *AnnualAuditController) DeleteNewFile() {
	Id := this.Ctx.Input.Param(":Id")
	var errinfo ErrorInfo
	if Id == "" {
		errinfo.Message = "操作失败！请求信息不完整"
		errinfo.Code = -2
		this.Data["json"] = &errinfo
		this.ServeJSON()
		return
	}

	svc := infochange.GetInfoChangeService(utils.DBE)

	where := "FileId=" + Id
	err := svc.DeleteEntityBytbl(OilAnnualChangeDetailName, where)

	if err == nil {
		errinfo.Message = "删除成功"
		errinfo.Code = 0
		this.Data["json"] = &errinfo
		this.ServeJSON()
	} else {
		errinfo.Message = "删除失败！" + utils.AlertProcess(err.Error())
		errinfo.Code = -1
		this.Data["json"] = &errinfo
		this.ServeJSON()
	}
}

// @Title 删除添加的资质
// @Description
// @Success 200 {object} ErrorInfo
// @Failure 403 :id 为空
// @router /deleteaddfile/:Id [delete]
func (this *AnnualAuditController) DeleteAddFile() {
	Id := this.Ctx.Input.Param(":Id")
	var errinfo ErrorInfo
	if Id == "" {
		errinfo.Message = "操作失败！请求信息不完整"
		errinfo.Code = -2
		this.Data["json"] = &errinfo
		this.ServeJSON()
		return
	}

	svc := infochange.GetInfoChangeService(utils.DBE)

	var file supplierfile.OilSupplierFile
	has1 := svc.GetEntity(&file, "Id="+Id)
	if !has1 {
		errinfo.Message = "删除失败"
		errinfo.Code = -1
		this.Data["json"] = &errinfo
		this.ServeJSON()
		return
	}
	// 如果有正在进行中的流程,不允许删除任何资质
	var certList []suppliercert.OilSupplierCert
	svc.GetEntitysByWhere(OilSupplierCertName, "Status > 0 and Status < 8 and SupplierId = "+strconv.Itoa(file.SupplierId), &certList)
	var appendList suppliercertappend.OilSupplierCertAppend
	svc.GetEntityByWhere(OilSupplierCertAppendName, "Status > 0 and Status < 8 and SupplierId = "+strconv.Itoa(file.SupplierId), &appendList)
	var infoList infochange.OilInfoChange
	svc.GetEntityByWhere(OilInfoChangeName, "Status > 0 and Status < 8 and SupplierId = "+strconv.Itoa(file.SupplierId), &infoList)
	if len(certList) > 0 || appendList.Id > 0 || infoList.Id > 0 {
		errinfo.Message = "有正在审核中的流程,不允许删除任何资质"
		errinfo.Code = -1
		this.Data["json"] = &errinfo
		this.ServeJSON()
		return
	}

	where := "FileId=" + Id
	err := svc.DeleteEntityBytbl(OilAnnualChangeDetailName, where)

	where1 := "Id=" + Id
	err = svc.DeleteEntityBytbl(OilSupplierFileName, where1)

	if err == nil {
		errinfo.Message = "删除成功"
		errinfo.Code = 0
		this.Data["json"] = &errinfo
		this.ServeJSON()
	} else {
		errinfo.Message = "删除失败！" + utils.AlertProcess(err.Error())
		errinfo.Code = -1
		this.Data["json"] = &errinfo
		this.ServeJSON()
	}
}

// @Title 添加资质
// @Description 添加资质
// @Success	200	{object}
// @router /addqualchange/:id [post]
func (this *AnnualAuditController) AddAppChange() {
	id := this.Ctx.Input.Param(":id")
	var errinfo ErrorInfo
	if id == "" {
		errinfo.Message = "操作失败！请求信息不完整"
		errinfo.Code = -2
		this.Data["json"] = &errinfo
		this.ServeJSON()
		return
	}
	var model annualaudit.OilAnnualChangeDetail
	var jsonblob = this.Ctx.Input.RequestBody
	json.Unmarshal(jsonblob, &model)

	svc := qualchange.GetQualChangeService(utils.DBE)

	var file supplierfile.OilSupplierFile
	where := "SupplierId = '" + strconv.Itoa(model.SupplierId) + "' and NeedFileType='" + model.NeedFileType + "'"
	has := svc.GetEntity(&file, where)

	var tableHeader tableheader.BaseTableheader
	where1 := "Name = '" + model.NeedFileType + "'"
	svc.GetEntityByWhere(BaseTableHeader, where1, &tableHeader)

	if has {
		errinfo.Message = "操作失败！该资质已添加"
		errinfo.Code = -1
		this.Data["json"] = &errinfo
		this.ServeJSON()
		return
	}

	file.SupplierId = model.SupplierId
	file.SupplierTypeCode = model.SupplierTypeCode
	file.IsManuf = tableHeader.IsManuf
	file.NeedFileType = model.NeedFileType
	file.FileType = 0
	file.SupType = 2
	file.CreateOn = time.Now()
	file.CreateUserId, _ = strconv.Atoi(this.User.Id)
	file.CreateBy = this.User.Realname
	file.FileUrl = strings.Trim(model.FileUrl, "$")
	file.FileName = strings.Trim(model.FileName, "$")
	file.EffectDate = model.EffectDate
	file.OtherRemark = model.Remark

	svc.InsertEntity(&file)

	model.ParentId, _ = strconv.Atoi(id)
	model.FileId = file.Id
	model.FileUrl = strings.Trim(model.FileUrl, "$")
	model.FileName = strings.Trim(model.FileName, "$")

	var err error
	var qualdetaimodel []annualaudit.OilAnnualChangeDetail

	qdwhere := " SupplierId = " + utils.ToStr(model.SupplierId) + " and FileId = " + utils.ToStr(file.Id) + " and ParentId=" + id
	svc.GetEntitysByWhere(OilAnnualChangeDetailName, qdwhere, &qualdetaimodel)
	if len(qualdetaimodel) == 0 {
		model.CreateOn = time.Now()
		model.CreateBy = this.User.Realname
		model.CreateUserId, _ = utils.StrTo(this.User.Id).Int()
		_, err = svc.InsertEntityBytbl(OilAnnualChangeDetailName, &model)
	} else {
		err = svc.UpdateEntityBywheretbl(OilAnnualChangeDetailName, &model, []string{"OldEffectDate", "FileUrl", "FileName", "OtherRemark"}, qdwhere)
	}

	if err == nil {
		errinfo.Message = "操作成功！"
		errinfo.Code = 0
		this.Data["json"] = &errinfo
		this.ServeJSON()
	} else {
		errinfo.Message = "操作失败！" + utils.AlertProcess(err.Error())
		errinfo.Code = -1
		this.Data["json"] = &errinfo
		this.ServeJSON()
	}
}

// @Title 交费用户确认交费
// @Description 交费用户确认交费
// @Success 200 {object} controllers.Request
// @router /update-pay-status/:id [post]
func (this *AnnualAuditController) UpdatePayStatus() {
	annualId := this.Ctx.Input.Param(":id")
	var errinfo ErrorInfo
	if annualId == "" {
		errinfo.Message = "操作失败！请求信息不完整"
		errinfo.Code = -2
		this.Data["json"] = &errinfo
		this.ServeJSON()
		return
	}
	annualAuditSrv := annualaudit.GetOilAnnualAuditService(utils.DBE)
	var annualAuditEntity annualaudit.OilAnnualAudit
	annualAuditSrv.GetEntityById(annualId, &annualAuditEntity)

	paySrv := paymentinfo.GetPaymentService(utils.DBE)
	var paymentInfoEntities []paymentinfo.OilPaymentInfo
	err := paySrv.GetPaymentInfoBySrcId(annualId, "2", &paymentInfoEntities)

	if err != nil {
		errinfo.Message = "未知错误，请稍后再试！"
		errinfo.Code = -1
		this.Data["json"] = &errinfo
		this.ServeJSON()
	}

	if len(paymentInfoEntities) == 1 {
		for _, item := range paymentInfoEntities {
			if item.IsPay == "1" {
				errinfo.Message = "已确认交费！请耐心等待"
				errinfo.Code = -1
				this.Data["json"] = &errinfo
				this.ServeJSON()
			}
			if item.IsPay == "2" {
				errinfo.Message = "已交费！请勿重复操作！"
				errinfo.Code = -1
				this.Data["json"] = &errinfo
				this.ServeJSON()
			}
		}
	}

	sql := "UPDATE OilPaymentInfo SET IsPay ='1' where SrcId=" + annualId
	annualAuditSrv.DBE.Exec(sql)
	errinfo.Message = "确认交费成功！"
	errinfo.Code = 0
	this.Data["json"] = &errinfo
	this.ServeJSON()
}