public async Task TestMethod_ConfirmSecurityCheck_ShouldFail_NoCode()
        {
            GatePassRepositoryTest.FLAG_GET_ASYNC = 0;
            SecurityUpdateStateViewModel gatePassView = new SecurityUpdateStateViewModel();
            var actualResult = await _securityServices.ConfirmSecurityCheck(gatePassView);

            Assert.AreEqual(ResponseCode.ERR_SEC_NOT_FOUND_GATEPASS, actualResult.errorCode);
        }
        public async Task TestMethod_ConfirmSecurityCheck()
        {
            SecurityUpdateStateViewModel gatePassView = new SecurityUpdateStateViewModel()
            {
                gatePassCode = "123"
            };
            var actualResult = await _securityServices.ConfirmSecurityCheck(gatePassView);

            Assert.IsNotNull(actualResult);
        }
        public async Task <ResponseViewModel <GatePassViewModel> > ConfirmSecurityCheck(SecurityUpdateStateViewModel updateStateView)
        {
            ResponseViewModel <GatePassViewModel> response;
            GatePass          queryGatePassResult;
            GatePassViewModel gatePassViewModel;
            State             queryStateResult;
            int tmpResponseCode;

            if (_unitOfWork.Exists() == false)
            {
                // Cound Not Connect to Database
                response = ResponseConstructor <GatePassViewModel> .ConstructData(ResponseCode.ERR_DB_CONNECTION_FAILED, null);
            }
            else if (updateStateView == null)
            {
                // Wrong request format
                response = ResponseConstructor <GatePassViewModel> .ConstructData(ResponseCode.ERR_SEC_WRONG_BODY_REQUEST_FORMAT, null);
            }
            else
            {
                // Get Queue by gatePassCode from database
                queryGatePassResult = await _gatePassRepository.GetAsync(q =>
                                                                         q.isDelete == false &&
                                                                         q.code == updateStateView.gatePassCode, QueryIncludes.SECURITY_GATEPASS_INCLUDES);

                // @TODO: Get permission of confirm RFID
                //
                bool isConfirmPermited = true;

                if (queryGatePassResult == null)
                {
                    // Not found GatePass
                    response = ResponseConstructor <GatePassViewModel> .ConstructData(ResponseCode.ERR_SEC_NOT_FOUND_GATEPASS, null);
                }
                else if (queryGatePassResult.state == null)
                {
                    // GatePass lacked "stateID" property
                    response = ResponseConstructor <GatePassViewModel> .ConstructData(ResponseCode.ERR_SEC_GATEPASS_LACK_STATEID, null);
                }
                else
                {
                    // Found the GatePass and State
                    if (isConfirmPermited == false)
                    {
                        // Not Permit
                        tmpResponseCode = ResponseCode.ERR_SEC_WRONG_CONFIRMED_RFID;
                    }
                    else
                    {
                        // Check requested updated state
                        switch (queryGatePassResult.state.ID)
                        {
                        case GatepassState.STATE_CALLING_1:
                        case GatepassState.STATE_CALLING_2:
                        case GatepassState.STATE_CALLING_3:
                        case GatepassState.STATE_IN_SECURITY_CHECK_IN:
                            // Get state ID of "Finish security check-in"
                            queryStateResult = await _stateRepository.GetAsync(s => s.ID == GatepassState.STATE_FINISH_SECURITY_CHECK_IN);     // STATE_SECURITY_CHECK_IN);

                            // Updat gatepass/state
                            queryGatePassResult.stateID   = queryStateResult.ID;
                            queryGatePassResult.enterTime = DateTime.Now;
                            tmpResponseCode = ResponseCode.SUCCESS;
                            break;

                        case GatepassState.STATE_FINISH_WEIGHT_OUT:
                            // Get state ID of "Finish security check-out"
                            queryStateResult = await _stateRepository.GetAsync(s => s.ID == GatepassState.STATE_FINISH_SECURITY_CHECK_OUT);     // STATE_SECURITY_CHECK_OUT);

                            // Updat gatepass/state
                            queryGatePassResult.stateID   = queryStateResult.ID;
                            queryGatePassResult.leaveTime = DateTime.Now;
                            queryGatePassResult.isDelete  = true;
                            queryGatePassResult.queueLists.First().isDelete = true;
                            if (queryGatePassResult.orders != null && queryGatePassResult.orders.Count > 0)
                            {
                                foreach (Order order in queryGatePassResult.orders)
                                {
                                    order.isDelete = true;
                                }
                            }
                            tmpResponseCode = ResponseCode.SUCCESS;
                            break;

                        default:
                            // NOT SUPPORT STATE
                            tmpResponseCode = ResponseCode.ERR_SEC_NOT_PERMIT_PASS_SECURITY_GATE;
                            break;
                        }
                    }

                    // Save on database
                    _unitOfWork.SaveChanges();

                    // @TODO: Update state record

                    // Re-query after changing
                    queryGatePassResult = await _gatePassRepository.GetAsync(q => q.code == updateStateView.gatePassCode, QueryIncludes.SECURITY_GATEPASS_INCLUDES);

                    gatePassViewModel = Mapper.Map <GatePass, GatePassViewModel>(queryGatePassResult);

                    // Return gatepass/truck
                    response = ResponseConstructor <GatePassViewModel> .ConstructData(tmpResponseCode, gatePassViewModel);
                }
            }
            return(response);
        }
 public async Task <ResponseViewModel <GatePassViewModel> > ConfirmSecurityCheck([FromBody] SecurityUpdateStateViewModel updateStateView)
 {
     return(await _securityServices.ConfirmSecurityCheck(updateStateView));
 }