2020년 8월 12일 수요일

[Unity] EventArgs 사용 예제

 이벤트 헨들러 실 사용예


FCE_JOB은 하나
FCE_INFO는 FCE 당 전부 붙어있음

FCE_JOB 에서 소재 생성을 하는 이벤트 만듬


public static EventHandler<CreateSlabEventArgs> CreateSlabEventHandler; //소재생성
CreateSlabEventHandler += OnFCECreateSlabEvent;


///역할은 그냥 단순히 slabNO을 받아서 웹소켓 요청
public void OnFCECreateSlabEvent(object sender, CreateSlabEventArgs eventArgs)
    {
        //사이즈 데이터 요청..
        WebSocket.r_FCESlabSizeData(eventArgs.slabNo);
    }

FCE_INFO 에서는
이런식으로 사용



FCE_JOB.CreateSlabEventHandler(this, new CreateSlabEventArgs() { fceNo = si.Fce_No, slabNo = si.Slab_No });





using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.Linq;
using System;

//SLAB소재에 대한 클래스
//디스플레이할 다른데이터도 추가 해야함
//아니면 따로 빼야하나??일단 보류





/// <summary>
/// 슬라브 생성 이벤트
/// 1. 형상화 정보 요청
/// 2. UI 표현? (일단 추가 안함)
/// </summary>
public class CreateSlabEventArgs : EventArgs
{
    public string slabNo;
    public int fceNo;
}


/// <summary>
/// 사이즈 데이터 전송 이벤트
/// 1.개별 FCE_NO에 따라 데이터 전송
/// </summary>
public class SizeEventArgs : EventArgs
{
    public TBL_FUR_SLAB_INF slabData;
}



/// <summary>
/// 트레킹정보 이벤트
/// 1.개별 FCE_NO에 따라 데이터 전송
/// </summary>
public class TRKEventArgs : EventArgs
{
    public TBL_FUR_SLAB_TRK slabTRKData;
}




public class FCE_JOB : MonoBehaviour {


    public static EventHandler<CreateSlabEventArgs> CreateSlabEventHandler; //소재생성


    public static EventHandler<SizeEventArgs> SizeEvnetHandler; //사이즈데이터
    public static EventHandler<TRKEventArgs> TRKEventHandler; //트레킹데이터

    
    
    //동작 로직의 순서는
    //1. 위치이동
    //2. 추출,장입
    //public delegate SLABDATA[] GetFceSlabDatas(SLABDATA[] datas);
    //public GetFceSlabDatas del_GetFceSlabDatas;

    public FCE_INFO[] fce_Infos;
    public TBL_FUR_SLAB_INF slabSizeData;
    //public SLABDATA c_LastData;//트레킹 데이터와 마지막 데이터 비교
    //public SLABDATA c_FirstData;

    IEnumerator cor_DataUpdate;

    //추출
    //TB_TRK 에 올라온 코일ID기반으로 SLAB번호 추적하여 비교


    //장입
    //slab01에 데이터가 처음 들어왔을때 & CS의 slab01데이터가 다를때


    //위치이동(순간이동,로직이동)
    //업데이트 주기마다 위치값 비교하여 로직이동
    //장입시 로직이 완료된 다음 위치 순간이동

    

    int checkTime = 1;//데이터업데이트 주기용

    private void Start()
    {

        //Screen.SetResolution(1920, 1080, true);

        StartDataUpdate();

        CreateSlabEventHandler += OnFCECreateSlabEvent;
        SizeEvnetHandler += OnFCESizeEvent;
        TRKEventHandler += OnFCETRKEvent;
        
    }

    public void OnFCECreateSlabEvent(object sender, CreateSlabEventArgs eventArgs)
    {
        //사이즈 데이터 요청..
        WebSocket.r_FCESlabSizeData(eventArgs.slabNo);
    }

    public void OnFCESizeEvent(object sender, SizeEventArgs items)
    {
        if (items.slabData._TBL_FUR_SLAB_INF_ITEM == null)
        {
            //Debug.Log("형상화 데이터가 없습니다");
            return;
        }

        for (int i = 0; i < fce_Infos.Length; i++)
        {

            if (fce_Infos[i].fce_No == items.slabData._TBL_FUR_SLAB_INF_ITEM.FCE_NO)
            {
                fce_Infos[i].mySizeInfo.Enqueue(items.slabData._TBL_FUR_SLAB_INF_ITEM);
            }
        }

    }


    public void OnFCETRKEvent(object sender, TRKEventArgs eventArgs)
    {

        //Debug.Log("갯수 : " + eventArgs.slabTRKData._TBL_FUR_SLAB_TRK_ITEM.Length);

        //if (eventArgs.slabTRKData._TBL_FUR_SLAB_TRK_ITEM.Count() != 4)
        //{
        //    Debug.Log("받아온데이터가 이상하다");
        //    return;
        //}

        //Debug.Log("count:" + eventArgs.slabTRKData._TBL_FUR_SLAB_TRK_ITEM.Count());
        foreach (var x in eventArgs.slabTRKData._TBL_FUR_SLAB_TRK_ITEM)
        {
            fce_Infos[x.FCE_NO - 1].DataBinding(x);
        }


        //for (int i = 0; i < fce_Infos.Length; i++)
        //{
        //    fce_Infos[i].DataBinding(eventArgs.slabTRKData._TBL_FUR_SLAB_TRK_ITEM[i].fc);
        //}
    }

   
    public void StartDataUpdate()
    {

        if (cor_DataUpdate != null)
        {
            StopCoroutine(cor_DataUpdate);
            cor_DataUpdate = null;
        }
        cor_DataUpdate = DataUpdate();
        StartCoroutine(cor_DataUpdate);
    }


    private void Update()
    {
        //업데이트에서 돌리기 
        if (WebSocket.cue_TBL_FUR_SLAB_INF.Count != 0)
        {
            SizeEvnetHandler(this, new SizeEventArgs() { slabData = WebSocket.cue_TBL_FUR_SLAB_INF.Dequeue()});
        }
    }

    public IEnumerator DataUpdate()
    {
        while (true)
        {
            if (WebSocket.cue_TBL_FUR_SLAB_TRKs.Count != 0)
            {
                TRKEventHandler(this, new TRKEventArgs() { slabTRKData = WebSocket.cue_TBL_FUR_SLAB_TRKs.Dequeue() });
                //더 간단하게 만들어보기
                if (checkTime != 5)
                    checkTime = 5;
            }

            yield return new WaitForSeconds(checkTime);

            //Debug.Log("FCE DataUpdate!!! 현재 주기:"+checkTime+"초");
        }
    }




}



##################################################
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using System.Linq;
using System;







public class FCE_INFO : MonoBehaviour
{
    
    public float CreateOffset; //처음 생성할때 위치 잡아주는 변수
    public Text txt_State;
    public Text txt_SlabNo;
    public Image Img_state;

    [Space]
    public furnaceTracking m_furnaceTracking;
    public SearchManager m_SearchManager;
    public int fce_No;
    public GameObject prefab_slab;
    public Transform Fce_Start_Init_Pos;
    public Transform CharePos;

    public List<SlabInfo> current_FceSlabDatas = new List<SlabInfo>(); //실제로 만들 prefab에 붙어있는 데이터
    public Queue<TBL_FUR_SLAB_INF_ITEM> mySizeInfo = new Queue<TBL_FUR_SLAB_INF_ITEM>();
    int moveDistance = 0;


    IEnumerator cor_Extract;
    IEnumerator cor_Charge;
    IEnumerator cor_Move;


    bool isChargeing;

    public static EventHandler<SlabDataEventArgs> SlabDataEventHandler;
    public class SlabDataEventArgs : EventArgs
    {
        public TBL_FUR_SLAB_INF_ITEM slabData;
    }



    public void Start()
    {
        SlabDataEventHandler += OnSizeDataBinding;
        SlabDataEventHandler += OnSizeDataShaping;
        isChargeing = false;
        
        //CreateOffset = 0.001f; //mm단위로 계산하면 정답은 100이 맞긴함 하지만 조금더 간격이 벌어졋으면 좋겠다고 하셧음
        CreateOffset = 0.001f; //mm단위로 계산하면 정답은 100이 맞긴함
    }

    private void Update()
    {
        if (mySizeInfo.Count != 0)
        {
            SlabDataEventHandler(this, new SlabDataEventArgs() { slabData = mySizeInfo.Dequeue() });
        }
        #region 테스트
        //if (Input.GetKeyDown("1"))
        //{
        //    LogManager.del_eventLog("Slab 장입 신호 : " + "SB76932 531");
        //}

        //if (Input.GetKeyDown("2"))
        //{
        //    LogManager.del_eventLog("Slab 장입 : " + "SB76932 531");
        //}

        //if (fce_No == 1 )
        //{
        //    if (Input.GetKeyDown("1"))
        //    {
        //        StartCoroutine(TEST(1));
        //    }

        //    if (Input.GetKeyDown("2"))
        //    {
        //        StartCoroutine(TEST(2));
        //    }
        //    if (Input.GetKeyDown("3"))
        //    {
        //        StartCoroutine(TEST(3));
        //    }
        //    if (Input.GetKeyDown("4"))
        //    {
        //        StartCoroutine(TEST(4));
        //    }
        //    if (Input.GetKeyDown("5"))
        //    {
        //        StartCoroutine(TEST(5));
        //    }
        //    if (Input.GetKeyDown("6"))
        //    {
        //        StartCoroutine(TEST(6));
        //    }
        //    if (Input.GetKeyDown("7"))
        //    {
        //        StartCoroutine(TEST(7));
        //    }
        //}
        #endregion
    }

    //IEnumerator TEST(int i)
    //{
    //    LogManager.del_eventLog("Down Coiler 동작 신호" + "CoilID_28700");
    //    yield return new WaitForSeconds(0.01f);
    //    LogManager.del_eventLog("Down Coiler 동작" + "CoilID_28700");
    //}


    public void OneCylcleMove(float sPos,float ePos)
    {
        m_furnaceTracking.func_Slab_Set_Position(sPos, ePos);
    }

    public void OnSizeDataBinding(object sender, SlabDataEventArgs eventArgs)
    {

        if (!current_FceSlabDatas.Exists(x => x.Slab_No == eventArgs.slabData.SLAB_NO))
        {
            //Debug.Log(this.gameObject.name + "해당 소재번호에 대한 정보가 존재하지 않음 :" + eventArgs.slabData.SLAB_NO);
            return;
        }

        SlabInfo cur_tmp = current_FceSlabDatas.Find(x => x.Slab_No == eventArgs.slabData.SLAB_NO);

        float offset = 0.001f;

        cur_tmp.Wth = eventArgs.slabData.SLAB_WID*0.1f;
        cur_tmp.Len = eventArgs.slabData.SLAB_LEN;
        cur_tmp.Thk = eventArgs.slabData.SLAB_THK*0.001f;
        cur_tmp.TGT = eventArgs.slabData.SLAB_T_TGT;

        
        //x len,y thk,z wth
        //너무 정두깨로 만들면 겹치는 사태 발생
        //가열로 내 소재 크기 
        cur_tmp.gameObject.transform.localScale = new Vector3(cur_tmp.Len * offset, cur_tmp.Thk * offset, cur_tmp.Wth * offset*0.9f);

        //가열로 내 소재 색깔
        //r 0.5
        //시작 g 0.26
        float colorValue = cur_tmp.Pos / 100;
        Renderer renderer = cur_tmp.transform.GetChild(0).GetComponent<Renderer>();
        if (cur_tmp.Pos < 24000)
        {
            renderer.material.SetColor("_Color", new Color(0.24f + (colorValue) * 0.001f, 0.1f, 0));
        }
        else
        {
            renderer.material.SetColor("_Color", new Color(0.24f + (colorValue) * 0.0015f, 0.1f, 0));
        }

        
        
        
    }

    public void OnSizeDataShaping(object sender, SlabDataEventArgs eventArgs)
    {
        SlabInfo cur_tmp = current_FceSlabDatas.Find(x => x.Slab_No == eventArgs.slabData.SLAB_NO);
        //Debug.Log("shaping 테스트!!!");
        //cur_tmp.gameObject.transform.localScale = new Vector3()

    }




    /// <summary>
    /// 추출
    /// </summary>
    /// /// <param name="data">추출할 소재 데이터</param>
    IEnumerator extractLogic(SlabInfo extractItem)
    {
        LogManager.del_eventLog("Slab 추출 : " + extractItem.Slab_No);
        State_Extract();
        
        //Debug.Log("Slab 추출 : " + extractItem.Slab_No);

        m_furnaceTracking.func_ExitLogic(extractItem.name, -8f);
        yield return new WaitForSeconds(5f);//5초 기다리는 이유가 있나?

        if (extractItem != null)
        {
            //Debug.Log("추출끝!!:" + extractItem.gameObject.name);

            m_SearchManager.Delete_btn(extractItem.Slab_No, fce_No - 1);
            int deleteIdx = current_FceSlabDatas.IndexOf(extractItem);
            Destroy(extractItem.gameObject);
            current_FceSlabDatas.RemoveAt(deleteIdx);
            isChargeing = false;
            State_Stay();
        }
    }

    /// <summary>
    /// 장입
    /// </summary>
    /// <param name="data">장입할 소재 데이터</param>
    IEnumerator ChargeLogic(GameObject chargeSlab)
    {
        //장입로직이 끝나면
        //장입시간 3초
        Debug.Log("장입로직시작! :" + chargeSlab.name);
        Debug.Log("장입로 위치로 순간이동:" + chargeSlab.name);

        LogManager.del_eventLog("Slab 장입 : " + chargeSlab.name);
        State_Extract();
        //m_furnaceTracking.func_EnterMove(0, 10 + padding, this.GetComponent<furnaceManager>());
        //장입로 시작위치로 이동시키기
        yield return new WaitForSeconds(1f);

        m_furnaceTracking.func_EnterMove(10, chargeSlab.name);

        yield return new WaitForSeconds(3f);
        //장입종료
        //순간이동?
        Debug.Log("장입로직끝! :" + chargeSlab.name);
        //움직일 거리가 있다면 가열로 움직이기 시작
        isChargeing = false;
        State_Stay();
        //    if (moveDistance != 0)
        //    {
        //        StartCoroutine(MoveLogic(moveDistance));
        //    }
    }
    
    


    /// <summary>
    /// 가열로 동작 루틴
    /// </summary>
    /// <param name="currentPos">시작위치</param>
    /// <param name="targetPos">목표위치</param>
    /// <returns></returns>
    IEnumerator MoveLogic(float currentPos,float targetPos)
    {

        //Debug.Log("currentPos:" + currentPos);
        //Debug.Log("targetPos:" + targetPos);
        //Debug.Log("isChargeing :" + isChargeing);

        yield return new WaitUntil(() => !isChargeing);

        //Debug.Log("Tracking시작!!");
        State_running();
        m_furnaceTracking.func_Slab_Set_Position(currentPos, targetPos);

        //움직이는게 끝나면
        yield return new WaitUntil(()=>m_furnaceTracking.OneCycle == null);
        moveDistance = 0;
        State_Stay();


    }



    public void CreateSlab(TBL_FUR_SLAB_TRK_ITEM.SlabTRKItem item)
    {
        if (string.IsNullOrEmpty( item.slabNo))
        {
            return;
        }

        GameObject GameObj = Instantiate(prefab_slab, Fce_Start_Init_Pos);
        SlabInfo si = GameObj.AddComponent<SlabInfo>();
        GameObj.name = "SlabNo_" + item.slabNo;
        si.Slab_No = item.slabNo;
        si.Pos = item.pos;
        si.Fce_No = fce_No;

        
        
        GameObj.transform.localPosition = new Vector3(0, 0, (si.Pos * CreateOffset));
        GameObj.transform.GetChild(1).GetComponent<TextMesh>().text = item.slabNo;
        string zone = "예열대";

        if (26900 > item.pos && item.pos >= 14400)
        {
            zone = "가열대";
        }
        else if (item.pos >= 26900)
        {
            zone = "균열대";
        }

        //형상화 정보 데이터 요청
        //WebSocket.reqSizeData(item.slabNo);
        //콜하는구문
        //붙어있는거 모든게 콜되는 방식임
        FCE_JOB.CreateSlabEventHandler(this, new CreateSlabEventArgs() { fceNo = si.Fce_No, slabNo = si.Slab_No });

        m_SearchManager.Create_btn(si.Slab_No, si.TGT, fce_No-1, zone, GameObj.transform.GetChild(0).gameObject);
        current_FceSlabDatas.Insert(0, si);
    }

    public void CreateSlab(TBL_FUR_SLAB_TRK_ITEM.SlabTRKItem item,Transform ChargePos)
    {

        Debug.Log("CreateSlab by ChargePos");

        if (item.slabNo == "")
        {
            //Debug.Log("return!!!!!!!");
            return;
        }

        GameObject GameObj = Instantiate(prefab_slab, ChargePos);
        SlabInfo si = GameObj.AddComponent<SlabInfo>();
        GameObj.name = "SlabNo_" + item.slabNo;
        si.Slab_No = item.slabNo;
        si.Pos = item.pos;
        si.Fce_No = fce_No;

        GameObj.transform.localPosition = new Vector3(0, 0, si.Pos * 0.001f);
        GameObj.transform.GetChild(1).GetComponent<TextMesh>().text = item.slabNo;
        string zone = "예열대";

        if (26900 > item.pos && item.pos >= 14400)
        {
            zone = "가열대";
        }
        else if (item.pos >= 26900)
        {
            zone = "균열대";
        }
        //형상화 정보 데이터 요청
        //WebSocket.reqSizeData(item.slabNo);
        //콜하는구문
        //붙어있는거 모든게 콜되는 방식임
        FCE_JOB.CreateSlabEventHandler(this, new CreateSlabEventArgs() { fceNo = si.Fce_No, slabNo = si.Slab_No });

        m_SearchManager.Create_btn(si.Slab_No, si.TGT, fce_No - 1, zone, GameObj.transform.GetChild(0).gameObject);
        current_FceSlabDatas.Insert(0, si);
    }









    /// <summary>
    /// 
    /// </summary>
    /// <param name="items">주기마다 업데이트되어서 들어온 데이터</param>
    public void DataBinding(TBL_FUR_SLAB_TRK_ITEM items)
    {

        //current_TRK_ITEM.GetSLabNo()
        //item.GetSLabNo()
        SlabInfo compare_item; // 현재 클라이언트의 데이터와 비교해서 있는것
        //가장처음 데이터 받아온 시점
        if (current_FceSlabDatas.Count == 0)
        {
            //바로생성
            for (int i = 0; i < items.slabTrkArr.Length; i++)
            {
                if (items.slabTrkArr[i].slabNo != null)
                    CreateSlab(items.slabTrkArr[i]);
            }

        }
        else
        {
            //추출체크
            CheckExtract(items);

            //비교
            for (int i = 0; i < items.slabTrkArr.Length; i++)
            {
                //compare_item = 현재 클라이언트에 존재하는 데이터
                compare_item = current_FceSlabDatas.FirstOrDefault(x => x.Slab_No == items.slabTrkArr[i].slabNo);

                if (compare_item == null)
                {
                    ///무조건 새로 생성하는곳 클라이언트에는 없고 받은데이터에는 있는데이터

                    if (i == 0)
                    {
                        if (current_FceSlabDatas[0].Slab_No != items.SLAB01)
                        {
                            //장입생성(아이템,장입위치)
                            CreateSlab(items.slabTrkArr[0], CharePos);

                            NullCheckStartCoroutine(cor_Charge, ChargeLogic(current_FceSlabDatas[0].gameObject));
                            //if (cor_Charge != null)
                            //{
                            //    StopCoroutine(cor_Charge);
                            //    cor_Charge = null;
                            //}
                            //cor_Charge = ChargeLogic(current_FceSlabDatas[0].gameObject);
                            //StartCoroutine(cor_Charge);
                            isChargeing = true;
                        }
                    }
                    else
                    {
                        if (items.slabTrkArr[i].slabNo != "")//NULL => ""로 변경 0115
                        {
                            //Debug.Log("null인데 생성???");
                            CreateSlab(items.slabTrkArr[i]);
                        }
                    }
                }
                else
                {
                    
                    //클라이언트에 있는 데이터가 들어왔다! (slab넘으로 비교했을때...)
                    //거리의 차이만큼 위치이동
                    moveDistance = items.slabTrkArr[i].pos - compare_item.Pos;
                    compare_item.Pos = items.slabTrkArr[i].pos;
                    
                    if (moveDistance > 0 && !isChargeing)
                    {
                        int currentPos = items.slabTrkArr[i].pos - moveDistance;

                        NullCheckStartCoroutine(cor_Move, MoveLogic(currentPos, compare_item.Pos));

                        //if (cor_Move != null)
                        //{
                        //    StopCoroutine(cor_Move);
                        //    cor_Move = null;
                        //}
                        //cor_Move = MoveLogic(currentPos, compare_item.Pos);
                        //StartCoroutine(cor_Move);

                        //현재 삭제된 것이라면 동작 로직이 필요가 없다??
                        //타이밍이 안맞아서items.slabTrkArr[i].slabNo 로는 체크를 할수가 없다
                    }



                }
            }
        }
    }



    public void CheckExtract(TBL_FUR_SLAB_TRK_ITEM items)
    {
        //추출 체크
        int isExtract;


        
        foreach (var exitItem in current_FceSlabDatas)
        {
            isExtract = 0; //위에서 선언하다 밑에서 선언으로 변경 한 아이템에 대한 조사만 하면 되니까
            foreach (var receiveItem in items.slabTrkArr)
            {
                if (exitItem.Slab_No == receiveItem.slabNo)
                {
                    isExtract = 1;
                }
            }

            if (isExtract == 0)
            {
                //추출해야할 데이터가 있음!!
                isChargeing = true;

                //두번실행되니까 비교용 Extractor 변수를 따로 만들어서 한번 Extractor를 한건지 채크하고 추출하자
                NullCheckStartCoroutine(cor_Extract, extractLogic(exitItem));
            }
        }

       
    }

    
    public void NullCheckStartCoroutine(IEnumerator cor, IEnumerator mydel)
    {
        if (cor != null)
        {
            StopCoroutine(cor);
            cor = null;
        }
        cor = mydel;
        StartCoroutine(cor);
    }


    void State_running()
    {
        txt_State.text = "Running";
        Img_state.color = new Color(0, 255, 0);
        if(current_FceSlabDatas.Count !=0)
            txt_SlabNo.text = current_FceSlabDatas[0].name;
    }

    void State_Charge()
    {
        txt_State.text = "Charge";
        Img_st

ate.color = new Color(0, 255, 0);
    }
    void State_Extract()
    {
        txt_State.text = "Extract";
        Img_state.color = new Color(0, 255, 0);
    }
    

    void State_Stay()
    {
        txt_State.text = "Stop";
        Img_state.color = new Color(255, 255, 255);
        txt_SlabNo.text = "";
    }


}

#################################################

[mssql] like, Group by, Union 사용 예

 


like를 이용해서 검색하는 쿼리



union,Group by 를 사용해서 데이터 추출하는 쿼리

[mssql] union GroupBy, 인자 엄청많이 받는 쿼리

 





미들웨어의 xmlquery파일중 하나.


인자가 엄청많다 130개 이상을 받아서 처리했엇다

[쿼리] 그룹 by Group by 컬럼

 

######### KPI3 해결 과정 ######### 


목표

9.KPI3 
    조회기간 : 1주일-> 1달 로변경
    
    탭 추가 : 전체,1,2,3,4
    
    가열로 당 A,B
    
    
    
    A = 실적입열량   -> TB_FUEL_KPI_Model   Date,Fce_No,Gas_Flow
    B = 예측입열량   -> TB_FUEL_KPI         Date,Fce_No,Gas_Flow
    C = A/B 비례개수
    result = C의 표준편차

    기본 계산공식 A,B,C

    A,B 도출 공식:
    0700~1900 오전 Sum(A),Sum(B) ,C = Sum(A)/Sum(B)
    1900~0700 오후 Sum(A),Sum(B) ,C = Sum(A)/Sum(B)
    result = avg(C) 의 표준편차

######### KPI3 해결 과정 ######### 


테이블에 있는 데이터 확인

TB_FUEL_KPI       ->예측
TB_FULE_KPI_MODEL ->실측

테이블 모양(간략화)

DATESTART,DATEEND,GAS_FLOW,FCE_NO 





원하는 데이터

특정 기간내 의 하루를 오전 오후로 나눈 시간의 
    TB_FUEL_KPI_MODEL의 SUM(GAS_FLOW) as GAS_FLOW_A
    TB_FUEL_KPI의 SUM(GAS_FLOW) as GAS_FLOW_B
    값(FCE_NO당)

어려웠던 점

일단 쿼리로 전부 합계까지 구해서 해결하려고 조인이나 여러가지를 써봤는데 중복으로 계산이 되어서 sum값을 찾을수가 없었다

이유는 기준이 되는 데이터가 없다 (DATE가 같지않음)

그래서 여러 컬럼이 1:N이 되어버려서 중복 계산이 되는것

그리고 A,B를 한번에 컬럼으로 뽑아내는 쿼리도...결국 실패하여서

TABLE 이름으로 나누어서 쿼리를 짜서 클라이언트에서 A,B를 구분하기로 함





결국은 오전의 결과 쿼리 + 오후의 결과 쿼리 

select *from(
  SELECT FCE_NO, MIN(DateStart) as startDate, MAX(DateStart) as endDate, SUM(Gas_Flow) as Gas_Flow_A, 'TB_FUEL_KPI_MODEL' as table_name
  FROM TB_FUEL_KPI_MODEL
  where {0} <= DateStart and DateStart< {1}
  GROUP by FCE_NO
  union
  Select FCE_NO, MIN(DateStart) as startDate,MAX(DateStart)as endDate,SUM(Gas_Flow) as Gas_Flow_B,'TB_FUEL_KPI' as table_name
  from TB_FUEL_KPI
  where
{0} <= DateStart and DateStart< {1}
  Group by Fce_No
)AS b

이 쿼리를 하면 결과값은

FCE_NO, startDate,endDate,Gas_Flow,table_name

으로 결과값이 나온다


그러면 클라이언트에서 데이터를 위의 형식으로 모든 날짜에 대하여 받는다



컨버팅 과정은 dictionary와 새로운 데이터클래스를 정의하여서 해결했다.

정의한 데이터 클래스

public class KPI3_Datas
{
    public int fce_no;
    public string startDT;
    public string endDT;
    public double Gas_A; //Tablename 이 TB_FUEL_KPI_MODEL이라면 A
    public double Gas_B; //Tablename이 TB_FUEL_KPI이라면 B
    public KPI3_Datas(int fce_no,string startDT,string endDT,double Gas_A,double Gas_B)
    {
        this.fce_no = fce_no;
        this.startDT = startDT;
        this.endDT = endDT;
        this.Gas_A = Gas_A;
        this.Gas_B = Gas_B;
    }
}

데이터를 한번 for문 쭉 돌리면 결국 A,B를 다 채울수 있다.
결론 :KPI3_Datas의 데이터는 두개의 데이터가 있어야 A,B가 다 찬다.

같은 데이터라는것은 key 값을 
    string key = x.Fce_No + x.endDate.Substring(0,9); //초단위 까지 말고 시단위 까지 같으면 같은걸로 쳐주자
    ///key 값 (enddate)값에 대한 dic가 있다면 비어있는 A,B중 하나를 채워준다.//string key = x.Fce_No + x.endDate.Substring(0, 10); 
        /////초단위 까지 말고 시단위 까지 같으면 같은걸로 쳐주자
    //데이터가 이상한건지 매칭이 잘 안됨 9까지 줄이자
    //20200702070000 => 2020070207 까지 줄이기 8까지 해야하나...
    
    이런식으로 시간 + fce_no을 해서 데이터를 구분했다.

실제 컨버팅 함수


foreach (var x in currentData._kPI3Items) ///서버에서 받은 데이터를 모두 확인한다.
        {
            //if (x.Fce_No == null)

            ///key 값 (enddate)값에 대한 dic가 있다면 비어있는 A,B중 하나를 채워준다.//string key = x.Fce_No + x.endDate.Substring(0, 10); 
            /////초단위 까지 말고 시단위 까지 같으면 같은걸로 쳐주자//데이터가 이상한건지 매칭이 잘 안됨 9까지 줄이자//20200702070000 => 2020070207 까지 줄이기 8까지 해야하나...
            string key = x.Fce_No + x.endDate.Substring(0,10); //초단위 까지 말고 시단위 까지 같으면 같은걸로 쳐주자\

            if (dic_date.ContainsKey(key))
            {
                //기존데이터라면 부족한 데이터를 채워준다
                if (x.table_name == "TB_FUEL_KPI_MODEL")
                    dic_date[key].Gas_A = x.Gas_Flow;
                else
                    dic_date[key].Gas_B = x.Gas_Flow;
            }
            else
            {
                KPI3_Datas tmp;
                ///새로운 데이터가 들어왔다면 table 이름에 따라 A,B를 채워준다
                switch (x.table_name)
                {
                    case "TB_FUEL_KPI_MODEL":
                        //A 실측값 TB_FULE_KPI_Model
                        tmp = new KPI3_Datas(x.Fce_No, x.startDate, x.endDate, x.Gas_Flow, 0);
                        dic_date.Add(key, tmp);
                        break;
                    case "TB_FUEL_KPI":
                        //B 예측값 TB_FULE_KPI
                        tmp = new KPI3_Datas(x.Fce_No, x.startDate, x.endDate, 0, x.Gas_Flow);
                        dic_date.Add(key, tmp);
                        break;
                }
            }
        }

























[Unity] ManualInventory , ManualSlot , ManualRollItem

 using System.Collections;

using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

public class ManualInventory : MonoBehaviour
{


    public static ManualInventory instance;

    //prefabs
    public Transform prefabs;
    public List<ManualSlot> manualSlots = new List<ManualSlot>();
    public Transform draggingItem;
    public ManualSlot enteredSlot;


    void Awake()
    {
        instance = this;
    }

    void Start()
    {
        New_SlotMake(10);

        //Debug.Log("ManulInventory Start!!!");
    }

    void Update()
    {
        if (Input.GetKeyDown("1"))
        {
            AddItem(ItemDatabase.instance.predict_rollItems);
        }

        if (Input.GetKeyDown("2"))
        {
            Init();
        }
    }


    
    public void GetData(Toggle toggle)
    {
        Init();
        if (toggle.isOn)
        {
            //Debug.Log("predict_rollItems Init!!!");   
            AddItem(ItemDatabase.instance.predict_rollItems);
        }
        else
        {
            AddItem(ItemDatabase.instance.Guidance_rollItems);
        }
    }





    void AddItem(List<ManualRollItem> items)
    {
        for (int i = 0; i < items.Count; i++)
        {
            manualSlots[i].item = items[i];
            ItemImageChange(manualSlots[i]);
        }
    }


    public void ItemImageChange(ManualSlot _slot)
    {
        _slot.item.Seq_NM = _slot.transform.GetSiblingIndex();

        if (_slot.item.itemValue == -1)
            _slot.transform.GetChild(0).gameObject.SetActive(false);
        else
        {
            _slot.transform.GetChild(0).gameObject.SetActive(true);
            _slot.transform.GetChild(0).GetChild(0).gameObject.SetActive(true);

            _slot.transform.GetChild(0).GetChild(0).GetChild(0).GetComponent<Text>().text = _slot.item.Seq_NM + "," + _slot.item.Roll_NM;
        }
    }




    void New_SlotMake( int yCount)
    {
        for (int y = 0; y < yCount; y++)
        {
            Transform newSlot = Instantiate(prefabs, transform);
            newSlot.name = "Slot" + (y + 1);
            newSlot.transform.GetChild(0).gameObject.SetActive(false);
            manualSlots.Add(newSlot.GetComponent<ManualSlot>());
        }
        Init();

    }
    void Init()
    {
        foreach (var x in manualSlots)
        {
            x.item = new ManualRollItem();
            x.transform.GetChild(0).gameObject.SetActive(false);
        }
    }
}





using System.Collections;
using System.Collections.Generic;
using UnityEngine;

[System.Serializable]
public class ManualRollItem  {

    public string Roll_NM;
    public int itemValue;
    public int Seq_NM;
    // Use this for initialization

    public ManualRollItem(string _Roll_NM,int _itemValue,int _Seq_NM)
    {
        Roll_NM = _Roll_NM;
        itemValue = _itemValue;
        Seq_NM = _Seq_NM;
    }

    public ManualRollItem()
    {
        itemValue = -1;
    }
}



using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.EventSystems;
public class ManualSlot : MonoBehaviour, IDragHandler, IPointerEnterHandler, IPointerExitHandler, IEndDragHandler
{
    public ManualRollItem item;

    public void OnDrag(PointerEventData data)
    {
        if (transform.childCount > 0)
        {
            transform.GetChild(0).parent = ManualInventory.instance.draggingItem;
        }
        ManualInventory.instance.draggingItem.GetChild(0).position = data.position;
    }

    public void OnPointerEnter(PointerEventData data)
    {
        ManualInventory.instance.enteredSlot = this;
    }

    public void OnPointerExit(PointerEventData data)
    {
        ManualInventory.instance.enteredSlot = null;
    }

    public void OnEndDrag(PointerEventData data)
    {
        ManualInventory.instance.draggingItem.GetChild(0).parent = transform;
        transform.GetChild(0).localPosition = Vector3.zero;

        //내용은 간단합니다. enteredSlot이 null이 아닐 때, 즉 비어있는 상태가 아닐 때 두 슬롯 간의 아이템 교환이 이루어지고 ItemImageChange 함수를 통해 아이템에 맞는 Image로 변경시켜 줍니다.
        if (ManualInventory.instance.enteredSlot != null)
        {
            ManualRollItem tempItem = item;
            item = ManualInventory.instance.enteredSlot.item;
            ManualInventory.instance.enteredSlot.item = tempItem;
            ManualInventory.instance.ItemImageChange(this);
            ManualInventory.instance.ItemImageChange(ManualInventory.instance.enteredSlot);
        }

        

    }

    
}





[Unity] dateTime to string,string to DateTime Convert[유니티] 시간을 글자로,글자를 시간으로 변환

 

 key 값

key = x.Fce_No + x.endDate.Substring(0, 14);

//가열로 번호 + endDate시간을 key로잡고

model에서는 받은 시간을 바탕으로 데이터를 뽑아낸다






foreach (var x in currentModelData._kPI3Items)
        {
            foreach (var item in dic_date)
            {
                
                if (string.Compare(x.Fce_No.ToString(), item.Key.Substring(0, 1)) ==0) // FceNo이 같고
                {
                    Debug.Log("key:" + item.Key);
                    CurrnetDate = DateTime.ParseExact(item.Key.Substring(1, 14), "yyyyMMddHHmmss",null);
                    prevDate = CurrnetDate.AddHours(-12);

                    //시작날짜가 이전날짜보다 크고
                    //끝날짜가 dictionary end데이트보다 작다면
                    //데이트 추가
                    if (DateTime.Compare(DateTime.ParseExact(x.startDate,"yyyyMMddHHmmss", null), prevDate) > 0
                        && DateTime.Compare(DateTime.ParseExact(x.endDate, "yyyyMMddHHmmss", null), CurrnetDate) < 0)
                    {
                        //
                        if (x.table_name == "TB_FUEL_KPI_MODEL")
                        {
                            item.Value.Gas_A = x.Gas_Flow;
                        }
                    }
                }
            }
            
        }




git rejected error(feat. cherry-pick)

 문제 아무 생각 없이 pull을 받지않고 로컬에서 작업! 커밋, 푸시 진행을 해버렷다. push에선 remote와 다르니 당연히 pull을 진행해라고 하지만 로컬에서 작업한 내용을 백업하지 않고 진행하기에는 부담스럽다(로컬작업 유실 가능성) 해결하려...