package service

import (
	"fmt"
	"strconv"
	"strings"
	"time"

	"github.com/linmadan/egglib-go/core/application"
	pgTransaction "github.com/linmadan/egglib-go/transaction/pg"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-manufacture/pkg/application/factory"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-manufacture/pkg/application/productTrouble/command"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-manufacture/pkg/application/productTrouble/dto"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-manufacture/pkg/application/productTrouble/query"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-manufacture/pkg/domain"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-manufacture/pkg/infrastructure/domainService"
)

// 事故管理
type ProductTroubleService struct{}

func NewProductTroubleService(options map[string]interface{}) *ProductTroubleService {
	newService := &ProductTroubleService{}
	return newService
}

func (srv ProductTroubleService) SaveProductTrouble(operateInfo *domain.OperateInfo, param *command.SaveProductTroubleCommand) (map[string]interface{}, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()

	productTroubleRepo, _ := factory.CreateProductTroubleRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	workShopRepo, _ := factory.CreateWorkshopRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	//获取车间数据
	workShopData, err := workShopRepo.FindOne(map[string]interface{}{
		"workshopId": param.WorkshopId,
	})
	if err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, "车间数据不能存在"+err.Error())
	}
	if workShopData.CompanyId != operateInfo.CompanyId {
		return nil, application.ThrowError(application.ARG_ERROR, "车间数据填写错误")
	}
	workStation, err := workShopData.FindWorkStation(param.WorkshopId, param.LineId, param.SectionId)
	if err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
	}

	recordDate, err := time.ParseInLocation("2006-01-02", param.RecordDate, time.Local)
	if err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, "日期格式错误")
	}
	var workerUser *domain.User
	userService := domainService.NewUserService()
	workerUser, err = userService.User(param.WorkerId)
	if err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, "获取员工信息失败，"+err.Error())
	}
	var troubleData *domain.ProductTrouble
	if param.Id > 0 {
		troubleData, err = productTroubleRepo.FindOne(map[string]interface{}{
			"id": param.Id,
		})
		if err != nil {
			return nil, application.ThrowError(application.ARG_ERROR, "事故数据填写错误")
		}
	} else {
		troubleData = &domain.ProductTrouble{
			CompanyId:     operateInfo.CompanyId,
			OrgId:         operateInfo.OrgId,
			CreatedAt:     time.Now(),
			ApproveStatus: domain.TroubleWaitApprove,
		}
	}

	troubleData.AmountLoss = param.AmountLoss
	troubleData.ProductWorker = *workerUser
	troubleData.RecordDate = recordDate
	troubleData.Remark = param.Remark
	troubleData.UpdatedAt = time.Now()
	troubleData.WorkStation = *workStation
	err = troubleData.SetTypes(param.Types)
	if err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
	}
	if param.SaveAndApprove {
		var approveUser *domain.User
		userService := domainService.NewUserService()
		approveUser, err = userService.User(operateInfo.UserId)
		if err != nil {
			return nil, application.ThrowError(application.ARG_ERROR, "获取审核人信息失败，"+err.Error())
		}
		err = troubleData.Approve(approveUser)
		if err != nil {
			return nil, application.ThrowError(application.ARG_ERROR, err.Error())
		}
	}
	_, err = productTroubleRepo.Save(troubleData)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	return map[string]interface{}{
		"id": troubleData.Id,
	}, nil
}

func (srv ProductTroubleService) GetProductTrouble(id int) (*dto.ProductTroubleInfo, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()

	productTroubleRepo, _ := factory.CreateProductTroubleRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	troubleData, err := productTroubleRepo.FindOne(map[string]interface{}{
		"id": id,
	})
	if err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, "事故数据不存在，"+err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}

	result := dto.ProductTroubleInfo{
		Id:           troubleData.Id,
		WorkshopId:   troubleData.WorkStation.WorkshopId,
		WorkshopName: troubleData.WorkStation.WorkshopName,
		LineId:       troubleData.WorkStation.LineId,
		LineName:     troubleData.WorkStation.LineName,
		SectionId:    troubleData.WorkStation.SectionId,
		SectionName:  troubleData.WorkStation.SectionName,
		Remark:       troubleData.Remark,
		ProductDate:  troubleData.RecordDate.Format("2006-01-02"),
		AmountLoss:   troubleData.AmountLoss,
		Types:        string(troubleData.Types),
		WorkerId:     troubleData.ProductWorker.UserId,
		WorkerName:   troubleData.ProductWorker.UserName,
	}
	return &result, nil
}

func (srv ProductTroubleService) DeleteProductTrouble(id int64) error {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
	productTroubleRepo, _ := factory.CreateProductTroubleRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	troubleData, err := productTroubleRepo.FindOne(map[string]interface{}{
		"id": id,
	})
	if err != nil {
		return application.ThrowError(application.ARG_ERROR, "事故数据不存在，"+err.Error())
	}
	_, err = productTroubleRepo.Remove(troubleData)
	if err != nil {
		return application.ThrowError(application.ARG_ERROR, err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	return nil
}

// 审核事故
func (srv ProductTroubleService) ApproveProductTrouble(operateInfo *domain.OperateInfo, id int64) error {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
	productTroubleRepo, _ := factory.CreateProductTroubleRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	troubleData, err := productTroubleRepo.FindOne(map[string]interface{}{
		"id": id,
	})
	if err != nil {
		return application.ThrowError(application.ARG_ERROR, "事故数据不存在，"+err.Error())
	}
	var approveUser *domain.User
	userService := domainService.NewUserService()
	approveUser, err = userService.User(operateInfo.UserId)
	if err != nil {
		return application.ThrowError(application.ARG_ERROR, "获取审核人信息失败，"+err.Error())
	}
	err = troubleData.Approve(approveUser)
	if err != nil {
		return application.ThrowError(application.ARG_ERROR, err.Error())
	}

	troubleData.UpdatedAt = time.Now()
	_, err = productTroubleRepo.Save(troubleData)
	if err != nil {
		return application.ThrowError(application.ARG_ERROR, err.Error())
	}

	//汇总奖惩明细
	summaryServe, _ := domainService.NewPGRewardSummaryStaticService(transactionContext.(*pgTransaction.TransactionContext))
	err = summaryServe.CreateRewardSummaryByProductTrouble(troubleData)
	if err != nil {
		return application.ThrowError(application.ARG_ERROR, "计算功过奖惩明细失败，"+err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	return nil
}

// ListProductTrouble 事故管理列表
func (srv ProductTroubleService) ListProductTrouble(param *query.ListProductTrouble) (int64, []dto.ProductTroubleList, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return 0, nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return 0, nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()

	productTroubleRepo, _ := factory.CreateProductTroubleRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	limit := param.PageSize
	offset := param.PageSize * (param.PageNumber - 1)
	condition := map[string]interface{}{
		"limit":     limit,
		"offset":    offset,
		"companyId": param.CompanyId,
		"orgId":     param.OrgId,
	}

	if len(param.WorkerName) > 0 {
		condition["productWorkerName"] = param.WorkerName
	}

	if len(param.WorkshopName) > 0 {
		condition["workshopName"] = param.WorkshopName
	}
	cnt, troubleDataList, err := productTroubleRepo.Find(condition)
	if err != nil {
		return 0, nil, application.ThrowError(application.ARG_ERROR, "事故数据不存在，"+err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return 0, nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}

	result := []dto.ProductTroubleList{}
	var item dto.ProductTroubleList
	for _, v := range troubleDataList {
		item = dto.ProductTroubleList{
			Id:                v.Id,
			WorkshopId:        v.WorkStation.WorkshopId,
			WorkshopName:      v.WorkStation.WorkshopName,
			LineId:            v.WorkStation.LineId,
			LineName:          v.WorkStation.LineName,
			SectionId:         v.WorkStation.SectionId,
			SectionName:       v.WorkStation.SectionName,
			Remark:            v.Remark,
			ProductDate:       v.RecordDate.Local().Format("2006-01-02"),
			AmountLoss:        v.AmountLoss,
			Types:             v.GetTypesName(),
			WorkerId:          v.ProductWorker.UserId,
			WorkerName:        v.ProductWorker.UserName,
			ApproveStatus:     int(v.ApproveStatus),
			ApproveStatusName: v.GetApproveStatusName(),
		}
		result = append(result, item)
	}

	return cnt, result, nil
}

// 批量添加事故数据
func (srv ProductTroubleService) BatchAddProductTrouble(operateInfo *domain.OperateInfo, param []command.BatchAddProductTroubleCommand) (failRows []interface{}, err error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()

	//获取当前操作人
	userSrv := domainService.NewUserService()
	operateUser, err := userSrv.User(operateInfo.UserId)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, "查询操作人数据失败。"+err.Error())
	}

	//生产班组 数据
	productGroupRepo, _ := factory.CreateProductGroupRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	_, productGroupList, err := productGroupRepo.Find(map[string]interface{}{
		"companyId": operateInfo.CompanyId,
		"orgId":     operateInfo.OrgId,
	})
	if err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}
	//车间名称+/+线别名称+/+工段名称  作为键名
	workStationMap := map[string]*domain.WorkStation{}
	//车间名称+/+工人名  作为键名
	workerMap := map[string][]*domain.User{}
	//班组名称   作为键名
	productGroupMap := map[string]*domain.ProductGroup{}
	for _, v := range productGroupList {
		workStationName := strings.Join([]string{
			v.WorkStation.WorkshopName, v.WorkStation.LineName, v.WorkStation.SectionName,
		}, "/")
		workStationMap[workStationName] = v.WorkStation
		productGroupMap[v.GroupName] = v
		for _, vv := range v.GroupMembers {
			k := v.WorkStation.WorkshopName + "/" + vv.UserName
			isIn := false
			for _, vvv := range workerMap[k] {
				if vvv.UserId == vv.UserId {
					isIn = true
					break
				}
			}
			if !isIn {
				workerMap[k] = append(workerMap[k], vv)
			}
		}
	}

	troubleDataList := make([]*domain.ProductTrouble, 0, len(param))
	nowTime := time.Now()
	for i := range param {
		//检查字段
		err = param[i].ValidField()
		if err != nil {
			param[i].FailReason = err.Error()
			failRows = append(failRows, param[i])
			continue
		}
		//检查日期格式
		recordDate, err := time.ParseInLocation("2006-01-02", param[i].RecordDate, time.Local)
		if err != nil {
			param[i].FailReason = "日期格式错误，例 2006-01-02。"
			failRows = append(failRows, param[i])
			continue
		}
		//检查工位
		var workStation *domain.WorkStation
		workStationName := param[i].WorkerName + "/" + param[i].LineName + "/" + param[i].SectionName
		if v, ok := workStationMap[workStationName]; ok {
			workStation = v
		} else {
			param[i].FailReason = "车间、线别、工段不存在"
			failRows = append(failRows, param[i])
			continue
		}
		//检查员工姓名
		var worker *domain.User
		workKey := param[i].WorkshopName + "/" + param[i].WorkerName
		if u, ok := workerMap[workKey]; ok {
			if len(u) > 1 {
				param[i].FailReason = "当前车间存在重复的用户名"
				failRows = append(failRows, param[i])
				continue
			}
			worker = u[0]
		} else {
			param[i].FailReason = "当前车间不存在用户" + param[i].WorkerName
			failRows = append(failRows, param[i])
			continue
		}
		//损失金额
		amountLoss, err := strconv.ParseFloat(param[i].AmountLoss, 64)
		if err != nil {
			param[i].FailReason = "损失金额填写错误"
			failRows = append(failRows, param[i])
			continue
		}
		item := &domain.ProductTrouble{
			Id:            0,
			CompanyId:     operateInfo.CompanyId,
			OrgId:         operateInfo.OrgId,
			WorkStation:   *workStation,
			ProductWorker: *worker,
			AmountLoss:    amountLoss,
			Types:         "",
			RecordDate:    recordDate,
			Remark:        "",
			ApproveStatus: domain.TroubleIsApprove,
			ApproveAt:     &nowTime,
			ApproveUser:   operateUser,
			CreatedAt:     nowTime,
			UpdatedAt:     nowTime,
			DeletedAt:     nil,
		}
		err = item.SetTypes(param[i].TypesName)
		if err != nil {
			param[i].FailReason = "事故类型填写错误"
			failRows = append(failRows, param[i])
			continue
		}
		troubleDataList = append(troubleDataList, item)
	}

	if len(failRows) > 0 {
		return failRows, nil
	}
	productTroubleRepo, _ := factory.CreateProductTroubleRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	summaryServe, _ := domainService.NewPGRewardSummaryStaticService(transactionContext.(*pgTransaction.TransactionContext))
	for i := range troubleDataList {
		//添加事故数据
		_, err = productTroubleRepo.Save(troubleDataList[i])
		if err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		//汇总奖惩明细
		err = summaryServe.CreateRewardSummaryByProductTrouble(troubleDataList[i])
		if err != nil {
			return nil, application.ThrowError(application.ARG_ERROR, "计算功过奖惩明细失败，"+err.Error())
		}
	}

	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	return nil, nil
}

// 奖惩汇总数据列表
func (srv ProductTroubleService) ListRewardSummary(param *query.ListRewardSummaryQuery) (int64, []dto.RewardSummaryList, error) {

	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return 0, nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return 0, nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()

	rewardSummaryRepo, _ := factory.CreateRewardSummaryRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	limit := param.PageSize
	offset := param.PageSize * (param.PageNumber - 1)
	condition := map[string]interface{}{
		"orgId":     param.OrgId,
		"companyId": param.CompanyId,
		"offset":    offset,
		"limit":     limit,
	}
	//搜索条件日期
	if len(param.BeginDate) > 0 {
		_, err = time.Parse("2006-01-02", param.BeginDate)
		if err != nil {
			return 0, nil, application.ThrowError(application.ARG_ERROR, "日期格式错误")
		} else {
			condition["beginDate"] = param.BeginDate
		}

	}
	//搜索条件日期
	if len(param.EndDate) > 0 {
		_, err = time.Parse("2006-01-02", param.EndDate)
		if err != nil {
			return 0, nil, application.ThrowError(application.ARG_ERROR, "日期格式错误")
		} else {
			condition["endDate"] = param.EndDate
		}

	}
	//搜索条件 车间名称
	if len(param.WorkshopName) > 0 {
		condition["workshopName"] = param.WorkshopName
	}
	//搜索条件 线别名称
	if len(param.LineName) > 0 {
		condition["lineName"] = param.LineName
	}

	cnt, rewardSummaryList, err := rewardSummaryRepo.Find(condition)
	if err != nil {
		return 0, nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return 0, nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}

	result := []dto.RewardSummaryList{}
	for _, v := range rewardSummaryList {
		item := dto.RewardSummaryList{
			Id:            v.Id,
			RecordDate:    v.RecordDate.Format("2006-01-02"),
			WorkshopName:  v.WorkStation.WorkshopName,
			LineName:      v.WorkStation.LineName,
			SectionName:   v.WorkStation.SectionName,
			WorkerName:    v.Worker.UserName,
			Yield:         fmt.Sprintf("%.2f", v.Yield),
			UpToStandard:  fmt.Sprintf("%.2f%%", v.UpToStandard),
			Accident1:     fmt.Sprintf("%d次%.2f元", v.AccidentNum1, v.AccidentAmount1),
			Accident2:     fmt.Sprintf("%d次%.2f元", v.AccidentNum2, v.AccidentAmount2),
			Accident3:     fmt.Sprintf("金属%d次，非金属%d次", v.AccidentNum3, v.AccidentNum4),
			SummaryResult: fmt.Sprintf("%v", v.SummaryResult),
			ResultDesc:    "",
		}
		if v.SummaryResult == 0 {
			item.ResultDesc = "不奖不惩"
		} else if v.SummaryResult > 0 {
			item.ResultDesc = "奖"
		} else {
			item.ResultDesc = "惩"
		}
		result = append(result, item)
	}
	return cnt, result, nil
}

// 创建事故数据
func (srv ProductTroubleService) CreateProductTrouble(operateInfo *domain.OperateInfo, param *command.CreateProductTroubleCommand) (map[string]interface{}, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()

	productTroubleRepo, _ := factory.CreateProductTroubleRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	workShopRepo, _ := factory.CreateWorkshopRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	//获取车间数据
	workShopData, err := workShopRepo.FindOne(map[string]interface{}{
		"workshopId": param.WorkshopId,
	})
	if err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, "车间数据不能存在"+err.Error())
	}
	if workShopData.CompanyId != operateInfo.CompanyId {
		return nil, application.ThrowError(application.ARG_ERROR, "车间数据填写错误")
	}
	workStation, err := workShopData.FindWorkStation(param.WorkshopId, param.LineId, param.SectionId)
	if err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
	}

	recordDate, err := time.ParseInLocation("2006-01-02", param.RecordDate, time.Local)
	if err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, "日期格式错误")
	}

	var operaterUser *domain.User
	userService := domainService.NewUserService()
	operaterUser, err = userService.User(operateInfo.UserId)
	if err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, "获取审核人信息失败，"+err.Error())
	}
	for _, workerId := range param.WorkerId {
		var workerUser *domain.User
		workerUser, err = userService.User(workerId)
		if err != nil {
			return nil, application.ThrowError(application.ARG_ERROR, "获取员工信息失败，"+err.Error())
		}
		var troubleData *domain.ProductTrouble
		if param.Id > 0 {
			troubleData, err = productTroubleRepo.FindOne(map[string]interface{}{
				"id": param.Id,
			})
			if err != nil {
				return nil, application.ThrowError(application.ARG_ERROR, "事故数据填写错误")
			}
		} else {
			troubleData = &domain.ProductTrouble{
				CompanyId:     operateInfo.CompanyId,
				OrgId:         operateInfo.OrgId,
				CreatedAt:     time.Now(),
				ApproveStatus: domain.TroubleWaitApprove,
			}
		}

		troubleData.AmountLoss = param.AmountLoss
		troubleData.ProductWorker = *workerUser
		troubleData.RecordDate = recordDate
		troubleData.Remark = param.Remark
		troubleData.UpdatedAt = time.Now()
		troubleData.WorkStation = *workStation
		err = troubleData.SetTypes(param.Types)
		if err != nil {
			return nil, application.ThrowError(application.ARG_ERROR, err.Error())
		}
		if param.SaveAndApprove {
			err = troubleData.Approve(operaterUser)
			if err != nil {
				return nil, application.ThrowError(application.ARG_ERROR, err.Error())
			}
		}
		_, err = productTroubleRepo.Save(troubleData)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}

	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	return map[string]interface{}{}, nil
}