package repository

import (
    "fmt"
    "time"
    "xorm.io/xorm"
    "xps/pkg/system/datamodel"
    "xps/pkg/system/viewmodel"
)

type ArtAttachRepo struct {
    engine *xorm.Engine
}

func NewArtAttachRepo(engine *xorm.Engine) *ArtCatRepo {
    return &ArtCatRepo{
        engine: engine,
    }
}

func (d *ArtRepo) GetListById(ocId, artId int64) ([]viewmodel.AttachInfo, error) {
    sqlSelect   := ` SELECT     A.file_id,
                                B.file_title,
                                B.dir_id,
                                B.file_icon,
                                B.file_url,
                                B.file_ext,
                                B.file_size,
                                B.file_author,
                                B.file_desc,
                                B.uploaded_by  AS uploader_id,
                                C.account_name AS uploader_name,
                                B.uploaded_at  `
    sqlFrom     := `FROM        art_attach  AS A
                    LEFT JOIN   doc_file    AS B ON(A.oc_id = B.oc_id AND A.file_id     = B.file_id)
                    LEFT JOIN   account     AS C ON(B.oc_id = C.oc_id AND B.uploaded_by = C.account_id)  `
    sqlWhere    := ` WHERE B.deleted_flag = 0 `
    sqlWhere    += fmt.Sprintf(" AND A.oc_id = %d ", ocId)
    sqlWhere    += fmt.Sprintf(" AND A.art_id = %d ", artId)

    sqlOrderBy := " ORDER BY A.issued_at DESC "
    datalist := make([]viewmodel.AttachInfo, 0)
    err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere + sqlOrderBy).Find(&datalist)
    if err != nil {
        return nil, err
    }
    return datalist, nil
}

func (d *ArtAttachRepo) Create(data *datamodel.ArtAttach) error {
    data.CreatedAt = time.Now()
    _, err := d.engine.Insert(data)
    return err
}

func (d *ArtAttachRepo) Delete(m map[string]interface{}) error {
    ocId        := m["ocId"].(int64)
    artId       := m["artId"].(int64)
    deletedBy   := m["deletedBy"].(int64)

    data := &datamodel.ArtAttach{}
    data.DeletedFlag = 1
    data.DeletedBy = deletedBy
    data.DeletedAt = time.Now()
    _, err := d.engine.
        Where("oc_id = ?", ocId).
        Where("art_id = ?", artId).
        Update(data)
    return err
}

func (d *ArtAttachRepo) DeleteById(m map[string]interface{}) error {
    ocId        := m["ocId"].(int64)
    artId       := m["artId"].(int64)
    fileId      := m["fileId"].(int64)
    deletedBy   := m["deletedBy"].(int64)

    data := &datamodel.ArtAttach{}
    data.DeletedFlag = 1
    data.DeletedBy = deletedBy
    data.DeletedAt = time.Now()
    _, err := d.engine.
        Where("oc_id = ?", ocId).
        Where("art_id = ?", artId).
        Where("file_id = ?", fileId).
        Update(data)
    return err
}