HYTOS

using System;

using System.ComponentModel.DataAnnotations;

/*

This class requires the System.ComponentModel.Annotations package and you can download it from https://www.nuget.org/packages/System.ComponentModel.Annotations

*/

namespace ID2.Manager.Dapper.Entities

{

	public class DOCUMENTITEM

	{

		[Key]

		[MaxLength(50)]

		public string ID {get; set;}

		[Required]

		[MaxLength(50)]

		public string REVISION {get; set;}

		[Required]

		[MaxLength(50)]

		public string DOCUMENT_NO {get; set;}

		[Required]

		[MaxLength(500)]

		public string DOCUMENT_NAME {get; set;}

		[Required]

		[MaxLength(500)]

		public string ORIGINAL_FILE {get; set;}

		[Required]

		[MaxLength(50)]

		public string DOCUMENT_ID {get; set;}

		[Required]

		[MaxLength(10)]

		public string PROJECT_NO {get; set;}

		[MaxLength(500)]

		public string Link {get; set;}

		public DateTime CreateDate {get; set;}

		[MaxLength(500)]

		public string RESULT_FILE {get; set;}

		[MaxLength(50)]

		public string RESULT {get; set;}

		[MaxLength(50)]

		public string GROUP_NO {get; set;}

	}

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace ID2.Manager.Dapper.Entities

{

    public class  DocPage

    {

        public string docinfo_id { get; set; }

        public int page_number { get; set; }

        public string page_width { get; set; }

        public string page_height { get; set; }

        public int page_angle { get; set; }

    }

}

    <Compile Include="Entities\DocPage.cs" />

    <Compile Include="Entities\DOCUMENTITEM.cs" />

    <Compile Include="Repository\MarkusRepository.cs" />

    <PackageReference Include="Dapper.ParameterExtensions">

      <Version>2022.7.7.1</Version>

    </PackageReference>

        public async Task<int> ExecuteAsync(string SQL, SqlMapper.IDynamicParameters parameters, IDbTransaction transaction, CommandType commandType)

        {

            if (_DbConnection.State != System.Data.ConnectionState.Open)

            {

                _DbConnection.Open();

            }

            return await _DbConnection.ExecuteAsync(SQL, parameters, transaction, commandType: commandType);

        }

using Dapper;

using DapperParameters;

using ID2.Manager.Dapper.Entities;

using System;

using System.Collections.Generic;

using System.Data;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace ID2.Manager.Dapper.Repository

{

    public class MarkusRepository : BaseRepository

    {

        public MarkusRepository(string connectionStr) : base(connectionStr) { }

        public async Task<bool> InsertAsync(string ProjectNo,string Name)

        {

            bool result = false;

            var convertDocID = await CreateConvertDocAsync(ProjectNo, Name, Name);

            if (convertDocID != null)

            {

                var docInfoID = await CreateDocInfoAsync(convertDocID, 1);

                var docPageResult = await CreateDocPageAsync(new[]{

                new DocPage {

                    page_angle = 0,

                    page_height = "1",

                    page_width  = "1",

                    page_number = 1

                } });

                var documentItemID = await CreateOrUPdateDocItemAsync(

                    new DOCUMENTITEM

                    {

                        REVISION = "0",

                        PROJECT_NO = ProjectNo,

                        DOCUMENT_NO = Name,

                        GROUP_NO = Name,

                        DOCUMENT_NAME = Name,

                        ORIGINAL_FILE = Name,

                        DOCUMENT_ID = Name

                    });

                if(docInfoID != null && docPageResult && documentItemID != null)

                {

                    result = true;

                }

            }

            return result;

        }

        /// <summary>

        /// 완료

        /// </summary>

        /// <param name="PROJECT_NO"></param>

        /// <param name="DOCUMENT_URL"></param>

        /// <param name="DOCUMENT_ID"></param>

        /// <returns></returns>

        public async Task<string> CreateConvertDocAsync(string PROJECT_NO, string DOCUMENT_URL, string DOCUMENT_ID)

        {

            string result = null;

            try

            {

                var tran = BeginTransaction();

                var parameters = new DynamicParameters();

                parameters.Add("@project_no", value: PROJECT_NO);

                parameters.Add("@document_url", value: DOCUMENT_URL);

                parameters.Add("@document_id", value: DOCUMENT_ID);

                parameters.Add("@newid", direction: ParameterDirection.Output);

                await base.ExecuteAsync("convert_insert_convertdoc", parameters, transaction: tran, commandType: CommandType.StoredProcedure);

                tran.Commit();

                result = parameters.Get<string>("newid");

            }

            catch (Exception ex)

            {

                throw ex;

            }

            return result;

        }

        /// <summary>

        /// 

        /// </summary>

        /// <param name="documentItem"></param>

        /// <returns>Create or Update id</returns>

        public async Task<string> CreateOrUPdateDocItemAsync(DOCUMENTITEM documentItem)

        {

            string result = null;

            var tran = BeginTransaction();

            var parameter = new DynamicParameters();

            parameter.Add("@revision", documentItem.REVISION);

            parameter.Add("@document_no", documentItem.DOCUMENT_NO);

            parameter.Add("@document_name", documentItem.DOCUMENT_NAME);

            parameter.Add("@original_file", documentItem.ORIGINAL_FILE);

            parameter.Add("@document_id", documentItem.DOCUMENT_ID);

            parameter.Add("@project_no", documentItem.PROJECT_NO);

            parameter.Add("@link", documentItem.Link);

            parameter.Add("@result_file", documentItem.RESULT_FILE);

            parameter.Add("@result", documentItem.RESULT);

            parameter.Add("@group_no", documentItem.GROUP_NO);

            parameter.Add("@newid", direction: ParameterDirection.Output);

            await base.ExecuteAsync("convert_insert_documentitem", parameter, tran, commandType: CommandType.StoredProcedure);

            tran.Commit();

            result = parameter.Get<string>("newid");

            return result;

        }

        /// <summary>

        /// test 필요 transaction Commit 이후 parameter.get을 해야 commit이 된다.

        /// </summary>

        /// <param name="convertDocID"></param>

        /// <param name="PageCount"></param>

        /// <returns></returns>

        public async Task<string> CreateDocInfoAsync(string convertDocID, int PageCount)

        {

            string result = "";

            var tran = BeginTransaction();

            var parameters = new DynamicParameters();

            parameters.Add("@convert_id", convertDocID, dbType: DbType.String);

            parameters.Add("@page_count", PageCount, dbType: DbType.Int32);

            parameters.Add("@newid", dbType: DbType.String, direction: ParameterDirection.Output, size: 50);

            parameters.Add("@errorcode", dbType: DbType.Int32, direction: ParameterDirection.Output);

            parameters.Add("@error", dbType: DbType.String, direction: ParameterDirection.Output, size: 500);

            await base.ExecuteAsync("convert_insert_docinfo", parameters, tran, commandType: CommandType.StoredProcedure);

            var errorCode = parameters.Get<int>("errorcode");

            var error = parameters.Get<string>("error");

            if (errorCode > 0)

            {

                tran.Rollback();

                throw new Exception(error);

            }

            else

            {

                tran.Commit();

                result = parameters.Get<string>("newid");

            }

            return result;

        }

        public async Task<bool> CreateDocPageAsync(IEnumerable<DocPage> docPages)

        {

            bool result = false;

            try

            {

                var tran = BeginTransaction();

                var parameter = new DynamicParameters();

                parameter.AddTable("DOCPAGES", "TYPE_INSERT_DOCPAGE", docPages);

                var id = await base.ExecuteAsync("CONVERT_INSERT_DOCPAGE", parameter, tran, commandType: CommandType.StoredProcedure);

                tran.Commit();

                result = true;

            }

            catch (Exception ex)

            {

                throw new Exception("DOCPAGERepository CreateAsync error.", ex);

            }

            return result;

        }

    }

}