public async Task <ResponseViewModel <GenericResponseModel> > UpdateTruckOnWarehouseCheck(TheoryWeighValueModel theoryWeighValueModel)
{
ResponseViewModel <GenericResponseModel> response = new ResponseViewModel <GenericResponseModel>();
try
{
var gatePass = await _gatePassRepository.GetAsync(gt => gt.ID == theoryWeighValueModel.gatePassID && gt.isDelete == false, QueryIncludes.GATEPASSFULLINCLUDES);
if (gatePass == null)
{
return(response = ResponseConstructor <GenericResponseModel> .ConstructBoolRes(ResponseCode.ERR_SEC_UNKNOW, false));
}
else
{
switch (gatePass.stateID)
{
case GatepassState.STATE_FINISH_WEIGHT_IN:
return(await this.UpdateTruckOnWarehouseCheckIn(theoryWeighValueModel));
case GatepassState.STATE_FINISH_WAREHOUSE_CHECK_IN:
return(await this.UpdateTruckOnWarehouseCheckOut(theoryWeighValueModel));
default:
return(response = ResponseConstructor <GenericResponseModel> .ConstructBoolRes(ResponseCode.ERR_SEC_UNKNOW, false));
}
}
}
catch (Exception)
{
return(response = ResponseConstructor <GenericResponseModel> .ConstructBoolRes(ResponseCode.ERR_SEC_UNKNOW, false));
}
}
public async Task <ResponseViewModel <WeightRecordViewModel> > UpdateWeightValue(WeightDataViewModel weightDataViewModel)
{
ResponseViewModel <WeightRecordViewModel> response = new ResponseViewModel <WeightRecordViewModel>();
try
{
WeightRecord weightRecord = new WeightRecord();
Random r = new Random();
//if (await _authService.CheckUserPermission(weightDataViewModel.employeeID, weightDataViewModel.employeeRFID, "UpdateWeightValue"))
//{
var weighNum = await _weightRecordRepository.GetManyAsync(wt => wt.gatepassID == weightDataViewModel.gatePassID && wt.isDelete == false);
weightRecord.code = r.Next().ToString();
weightRecord.gatepassID = weightDataViewModel.gatePassID;
weightRecord.isDelete = false;
weightRecord.weighBridgeID = weightDataViewModel.weighBridgeID;
weightRecord.weighBridge = await _weighBridgeRepository.GetByIdAsync(weightDataViewModel.weighBridgeID);
weightRecord.weightEmployeeID = weightDataViewModel.employeeID;
weightRecord.employee = await _employeeRepository.GetByIdAsync(weightDataViewModel.employeeID);
weightRecord.weightTime = DateTime.Now;
weightRecord.weightValue = weightDataViewModel.weightValue;
weightRecord.frontCameraCapturePath = Constant.TruckCapturePath + weightDataViewModel.fontCameraName;
weightRecord.gearCameraCapturePath = Constant.TruckCapturePath + weightDataViewModel.gearCameraName;
weightRecord.cabinCameraCapturePath = Constant.TruckCapturePath + weightDataViewModel.cabinCameraName;
weightRecord.containerCameraCapturePath = Constant.TruckCapturePath + weightDataViewModel.containerCameraName;
weightRecord.weightNo = weighNum.Count() + 1;
var gatePass = await _gatePassRepository.GetAsync(gt => gt.ID == weightDataViewModel.gatePassID && gt.isDelete == false);
if (gatePass.stateID == GatepassState.STATE_FINISH_SECURITY_CHECK_IN)
{
gatePass.stateID = GatepassState.STATE_FINISH_WEIGHT_IN;
}
else if (gatePass.stateID == GatepassState.STATE_FINISH_WAREHOUSE_CHECK_OUT)
{
gatePass.stateID = GatepassState.STATE_FINISH_WEIGHT_OUT;
}
_gatePassRepository.Update(gatePass);
_weightRecordRepository.Add(weightRecord);
if (await _unitOfWork.SaveChangesAsync())
{
response = ResponseConstructor <WeightRecordViewModel> .ConstructBoolRes(ResponseCode.SUCCESS, true);
}
else
{
response = ResponseConstructor <WeightRecordViewModel> .ConstructBoolRes(ResponseCode.ERR_SEC_UNKNOW, false);
}
//}
//else
//{
// response = ResponseConstructor<WeightRecordViewModel>.ConstructBoolRes(ResponseCode.ERR_WEI_WEIGH_NOT_PERMITTED, false);
//}
return(response);
}
catch (Exception)
{
return(response = ResponseConstructor <WeightRecordViewModel> .ConstructBoolRes(ResponseCode.ERR_SEC_UNKNOW, false));
}
}
public async Task <ResponseViewModel <SystemFunctionViewModel> > GetUserPermission(int userID)
{
ResponseViewModel <SystemFunctionViewModel> response = new ResponseViewModel <SystemFunctionViewModel>();
Dictionary <string, SystemFunctionViewModel> systemFunctionViewModels = new Dictionary <string, SystemFunctionViewModel>();
var user = await _userRepository.GetAsync(us => us.ID == userID, QueryIncludes.USERFULLINCLUDES);
if (user == null)
{
return(response = ResponseConstructor <SystemFunctionViewModel> .ConstructData(ResponseCode.ERR_USER_NOT_EXSIT, null));
}
else
{
var employee = user.employees.FirstOrDefault();
foreach (var group in employee.groupMaps)
{
foreach (var function in group.employeeGroup.functionMaps)
{
try
{
systemFunctionViewModels.Add(function.systemFunction.Code, Mapper.Map <SystemFunction, SystemFunctionViewModel>(function.systemFunction));
}
catch (Exception)
{
continue;
}
}
}
response = ResponseConstructor <SystemFunctionViewModel> .ConstructEnumerableData(ResponseCode.SUCCESS, systemFunctionViewModels.Values.ToList());
}
return(response);
}
public async Task <ResponseViewModel <QueueListViewModel> > GetQueueList()
{
ResponseViewModel <QueueListViewModel> response = new ResponseViewModel <QueueListViewModel>();
try
{
var queueList = await _queueListRepository.GetManyAsync(qu => qu.isDelete == false, QueryIncludes.QUEUELISTFULLINCLUDES);
if (queueList == null)
{
response = ResponseConstructor <QueueListViewModel> .ConstructEnumerableData(ResponseCode.ERR_QUE_NO_QUEUE_FOUND, null);
}
else
{
response = ResponseConstructor <QueueListViewModel> .ConstructEnumerableData(ResponseCode.SUCCESS,
Mapper.Map <IEnumerable <QueueList>,
IEnumerable <QueueListViewModel> >(queueList));
}
return(response);
}
catch (Exception)
{
return(response = ResponseConstructor <QueueListViewModel> .ConstructEnumerableData(ResponseCode.ERR_QUE_NO_QUEUE_FOUND, null));
}
}
public async Task <ResponseViewModel <LaneMgntViewModel> > GetLaneForWarehouseManagement(string code)
{
ResponseViewModel <LaneMgntViewModel> responseViewModel = new ResponseViewModel <LaneMgntViewModel>();
List <LaneMgntViewModel> laneMgntViewModels = new List <LaneMgntViewModel>();
var lanes = await _laneRepository.GetManyAsync(ln => ln.loadingBay.code.Equals(code) && ln.isDelete == false, QueryIncludes.LANEFULLINCLUDES);
foreach (var lane in lanes)
{
LaneMgntViewModel laneMgntViewModel = new LaneMgntViewModel();
laneMgntViewModel.ID = lane.ID;
laneMgntViewModel.LaneName = lane.nameVi;
if (lane.usingStatus == LaneStatus.OCCUPIED)
{
laneMgntViewModel.usingStatus = "Ocuppied";
}
else
{
laneMgntViewModel.usingStatus = "Free";
}
laneMgntViewModel.status = lane.status;
laneMgntViewModel.truckType = lane.truckType.description;
var queue = await _queueListRepository.GetAsync(qu => qu.laneID == lane.ID && qu.gatePass.isDelete == false && qu.gatePass.stateID == GatepassState.STATE_IN_WAREHOUSE_CHECK_IN, QueryIncludes.QUEUELISTFULLINCLUDES);
if (queue != null)
{
var gatePass = await _gatePassRepository.GetAsync(gt => gt.ID == queue.gatePass.ID, QueryIncludes.GATEPASSFULLINCLUDES); // await _gatePassRepository.GetAsync(gt => gt.queueLists.ToArray()[0].laneID == lane.ID && gt.isDelete == false);// && gt.stateID == GatepassState.STATE_FINISH_WAREHOUSE_CHECK_IN);
var start = (DateTime)gatePass.enterTime;
var end = (DateTime)gatePass.leaveTime;
end = end.AddMonths(1);
var now = DateTime.Now.Ticks;
var percent = ((now - start.Ticks) / (end.Ticks - start.Ticks)) * 100;
if (percent < (1 / 4))
{
laneMgntViewModel.progress = "0 %";
}
else if (percent > (1 / 4) && percent < (1 / 2))
{
laneMgntViewModel.progress = "50 %";
}
else if (percent > (1 / 2) && percent < 1)
{
laneMgntViewModel.progress = "75 %";
}
else
{
laneMgntViewModel.progress = "75 %";
}
laneMgntViewModel.KPI = gatePass.truck.KPI;
laneMgntViewModel.inTime = (DateTime)gatePass.enterTime;
laneMgntViewModel.outTime = (DateTime)gatePass.leaveTime;
laneMgntViewModel.plateNumber = gatePass.truck.plateNumber;
}
laneMgntViewModels.Add(laneMgntViewModel);
}
responseViewModel = ResponseConstructor <LaneMgntViewModel> .ConstructEnumerableData(ResponseCode.SUCCESS, laneMgntViewModels);
return(responseViewModel);
}
public async Task <ResponseViewModel <GenericResponseModel> > UpdateTruckOnWarehouseCheckIn(TheoryWeighValueModel theoryWeighValueModel)
{
ResponseViewModel <GenericResponseModel> response = new ResponseViewModel <GenericResponseModel>();
try
{
if (await _authService.CheckUserPermission(theoryWeighValueModel.employeeID, theoryWeighValueModel.employeeRFID, "UpdateTruckOnWarehouseCheckIn"))
{
var gatePass = await _gatePassRepository.GetAsync(gt => gt.ID == theoryWeighValueModel.gatePassID && gt.isDelete == false);
if (gatePass == null)
{
response = ResponseConstructor <GenericResponseModel> .ConstructBoolRes(ResponseCode.ERR_QUE_NO_GATEPASS_FOUND, false);
}
else
{
if (gatePass.stateID == GatepassState.STATE_FINISH_WEIGHT_IN)
{
gatePass.stateID = GatepassState.STATE_FINISH_WAREHOUSE_CHECK_IN;
var queue = await _queueListRepository.GetAsync(qu => qu.gatePassID == gatePass.ID);
var lane = await _laneRepository.GetAsync(ln => ln.ID == queue.laneID);
lane.usingStatus = LaneStatus.OCCUPIED;
_laneRepository.Update(lane);
_gatePassRepository.Update(gatePass);
if (await _unitOfWork.SaveChangesAsync())
{
response = ResponseConstructor <GenericResponseModel> .ConstructBoolRes(ResponseCode.SUCCESS, true);
}
else
{
response = ResponseConstructor <GenericResponseModel> .ConstructBoolRes(ResponseCode.ERR_SEC_UNKNOW, false);
}
}
else
{
response = ResponseConstructor <GenericResponseModel> .ConstructBoolRes(ResponseCode.ERR_QUE_GATEPASS_WRONG_STATE, false);
}
}
}
else
{
response = ResponseConstructor <GenericResponseModel> .ConstructBoolRes(ResponseCode.ERR_USER_PERMISSION, false);
}
return(response);
}
catch (Exception)
{
return(response = ResponseConstructor <GenericResponseModel> .ConstructBoolRes(ResponseCode.ERR_SEC_UNKNOW, false));
}
}
public ResponseViewModel <WeightRecordViewModel> AddTruckCamera(string fileName, byte[] fileContent)
{
ResponseViewModel <WeightRecordViewModel> response = new ResponseViewModel <WeightRecordViewModel>();
string filePath = Constant.DriverCapturePath + fileName;
// Write to file
if (fileName == null || fileContent == null)
{
response = ResponseConstructor <WeightRecordViewModel> .ConstructBoolRes(ResponseCode.ERR_SEC_UNKNOW, false);
}
else
{
File.WriteAllBytes(filePath, fileContent);
response = ResponseConstructor <WeightRecordViewModel> .ConstructBoolRes(ResponseCode.SUCCESS, true);
}
return(response);
}
public async Task <ResponseViewModel <GatePassViewModel> > GetGatePassByRFID(string rfidCode)
{
ResponseViewModel <GatePassViewModel> response;
GatePass queryGatePassResult;
GatePassViewModel gatePassViewModel;
RFIDCard queryRFIDResult;
if (_unitOfWork.Exists() == false)
{
response = ResponseConstructor <GatePassViewModel> .ConstructData(ResponseCode.ERR_DB_CONNECTION_FAILED, null);
}
else
{
// Find RFID ID
queryRFIDResult = await _rfidCardRepository.GetAsync(r => r.isDelete == false && r.code == rfidCode);
if (queryRFIDResult == null)
{
// Not found RFID tag on Database
response = ResponseConstructor <GatePassViewModel> .ConstructData(ResponseCode.ERR_SEC_NOT_FOUND_RFID, null);
}
else
{
// Query Gatepass by RFID tag
queryGatePassResult = await _gatePassRepository.GetAsync(
g => g.isDelete == false &&
g.RFIDCardID == queryRFIDResult.ID, QueryIncludes.SECURITY_GATEPASS_INCLUDES);
if (queryGatePassResult == null)
{
// Not Found Gatepass matched with RFID No
response = ResponseConstructor <GatePassViewModel> .ConstructData(ResponseCode.ERR_SEC_NOT_FOUND_GATEPASS, null);
}
else
{
// Found the GatePass
gatePassViewModel = Mapper.Map <GatePass, GatePassViewModel>(queryGatePassResult);
response = ResponseConstructor <GatePassViewModel> .ConstructData(ResponseCode.SUCCESS, gatePassViewModel);
}
}
}
return(response);
}
public async Task <ResponseViewModel <GenericResponseModel> > UpdateTheoryWeighValue(TheoryWeighValueModel theoryWeighValueModel)
{
ResponseViewModel <GenericResponseModel> response = new ResponseViewModel <GenericResponseModel>();
try
{
if (await _authService.CheckUserPermission(theoryWeighValueModel.employeeID, theoryWeighValueModel.employeeRFID, "UpdateTheoryWeighValue"))
{
var gatePass = await _gatePassRepository.GetAsync(gt => gt.ID == theoryWeighValueModel.gatePassID && gt.isDelete == false);
if (gatePass == null)
{
response = ResponseConstructor <GenericResponseModel> .ConstructBoolRes(ResponseCode.ERR_QUE_NO_GATEPASS_FOUND, false);
}
else
{
gatePass.theoryWeightValue = theoryWeighValueModel.theoryWeighValue;
_gatePassRepository.Update(gatePass);
if (await _unitOfWork.SaveChangesAsync())
{
response = ResponseConstructor <GenericResponseModel> .ConstructBoolRes(ResponseCode.SUCCESS, true);
}
else
{
response = ResponseConstructor <GenericResponseModel> .ConstructBoolRes(ResponseCode.ERR_SEC_UNKNOW, false);
}
}
}
else
{
response = ResponseConstructor <GenericResponseModel> .ConstructBoolRes(ResponseCode.ERR_USER_PERMISSION, false);
}
return(response);
}
catch (Exception)
{
return(response = ResponseConstructor <GenericResponseModel> .ConstructBoolRes(ResponseCode.ERR_SEC_UNKNOW, false));
}
}
public async Task <ResponseViewModel <WeightRecordViewModel> > GetWeightValueByGatePassID(int gatePassID)
{
ResponseViewModel <WeightRecordViewModel> response = new ResponseViewModel <WeightRecordViewModel>();
try
{
var weighRecord = await _weightRecordRepository.GetManyAsync(wt => wt.gatepassID == gatePassID && wt.isDelete == false);
if (weighRecord == null)
{
response = ResponseConstructor <WeightRecordViewModel> .ConstructEnumerableData(ResponseCode.ERR_QUE_WEIGH_NO_FOUND, Mapper.Map <IEnumerable <WeightRecord>, IEnumerable <WeightRecordViewModel> >(weighRecord));
}
else
{
response = ResponseConstructor <WeightRecordViewModel> .ConstructEnumerableData(ResponseCode.SUCCESS, Mapper.Map <IEnumerable <WeightRecord>, IEnumerable <WeightRecordViewModel> >(weighRecord));
}
return(response);
}
catch (Exception)
{
return(response = ResponseConstructor <WeightRecordViewModel> .ConstructEnumerableData(ResponseCode.ERR_SEC_UNKNOW, null));
}
}
public async Task <ResponseViewModel <UserViewModel> > Login(LoginViewModel loginViewModel)
{
ResponseViewModel <UserViewModel> response = new ResponseViewModel <UserViewModel>();
var user = await _userRepository.GetAsync(u => u.username == loginViewModel.Email && u.isDelete == false, QueryIncludes.USERFULLINCLUDES);
if (user == null)
{
return(response = ResponseConstructor <UserViewModel> .ConstructData(ResponseCode.ERR_USER_NOT_EXSIT, null));
}
if (user.password != Crypt.ToSha256(loginViewModel.Password))
{
return(response = ResponseConstructor <UserViewModel> .ConstructData(ResponseCode.ERR_INVALID_LOGIN, null));
}
var token = this.GenerateToken(user.ID, user.username, user.password, loginViewModel.UserHostAddress,
loginViewModel.UserAgent, DateTime.Now.Ticks);
UserViewModel viewModel = Mapper.Map <User, UserViewModel>(user);
viewModel.token = token;
response = ResponseConstructor <UserViewModel> .ConstructData(ResponseCode.SUCCESS, viewModel);
return(response);
}
public async Task <ResponseViewModel <QueueListViewModel> > GetTrucks(string truckCondition)
{
ResponseViewModel <QueueListViewModel> response;
IEnumerable <QueueList> queryResult;
IEnumerable <QueueListViewModel> truckOnQueueViewModel;
// Check connection to database
if (_unitOfWork.Exists() == false)
{
response = ResponseConstructor <QueueListViewModel> .ConstructEnumerableData(ResponseCode.ERR_DB_CONNECTION_FAILED, null);
}
else
{
switch (truckCondition)
{
case TRUCK_CONDITION_ALL:
queryResult = (await _queueListRepository.GetManyAsync(c => c.isDelete == false,
QueryIncludes.SECURITY_QUEUE_INCLUDES)
).ToArray().OrderBy(q => q.queueOrder).ToList();
truckOnQueueViewModel = Mapper.Map <IEnumerable <QueueList>, IEnumerable <QueueListViewModel> >(queryResult);
response = ResponseConstructor <QueueListViewModel> .ConstructEnumerableData(ResponseCode.SUCCESS, truckOnQueueViewModel);
break;
case TRUCK_CONDITION_CALLING:
queryResult = (await _queueListRepository.GetManyAsync(c =>
c.isDelete == false &&
(c.gatePass.state.ID == GatepassState.STATE_CALLING_1 ||
c.gatePass.state.ID == GatepassState.STATE_CALLING_2 ||
c.gatePass.state.ID == GatepassState.STATE_CALLING_3
),
QueryIncludes.SECURITY_QUEUE_INCLUDES)
).ToArray().OrderBy(q => q.queueOrder).ToList();
truckOnQueueViewModel = Mapper.Map <IEnumerable <QueueList>, IEnumerable <QueueListViewModel> >(queryResult);
response = ResponseConstructor <QueueListViewModel> .ConstructEnumerableData(ResponseCode.SUCCESS, truckOnQueueViewModel);
break;
case TRUCK_CONDITION_WAITING_CALL:
queryResult = (await _queueListRepository.GetManyAsync(c =>
c.isDelete == false &&
(
c.gatePass.state.ID == GatepassState.STATE_REGISTERED
), QueryIncludes.SECURITY_QUEUE_INCLUDES)
).ToArray().OrderBy(q => q.queueOrder).ToList();
truckOnQueueViewModel = Mapper.Map <IEnumerable <QueueList>, IEnumerable <QueueListViewModel> >(queryResult);
response = ResponseConstructor <QueueListViewModel> .ConstructEnumerableData(ResponseCode.SUCCESS, truckOnQueueViewModel);
break;
case TRUCK_CONDITION_1XXX_WAITING_CALL:
queryResult = (await _queueListRepository.GetManyAsync(c =>
c.isDelete == false &&
(
c.gatePass.state.ID == GatepassState.STATE_REGISTERED
) &&
c.gatePass.truckGroup.Code == TruckGroups.GROUP_1XXX,
QueryIncludes.SECURITY_QUEUE_INCLUDES)
).ToArray().OrderBy(q => q.queueOrder).ToList();
truckOnQueueViewModel = Mapper.Map <IEnumerable <QueueList>, IEnumerable <QueueListViewModel> >(queryResult);
response = ResponseConstructor <QueueListViewModel> .ConstructEnumerableData(ResponseCode.SUCCESS, truckOnQueueViewModel);
break;
case TRUCK_CONDITION_2XXX_WAITING_CALL:
queryResult = (await _queueListRepository.GetManyAsync(c =>
c.isDelete == false &&
(
c.gatePass.state.ID == GatepassState.STATE_REGISTERED
) &&
c.gatePass.truckGroup.Code == TruckGroups.GROUP_2XXX,
QueryIncludes.SECURITY_QUEUE_INCLUDES)
).ToArray().OrderBy(q => q.queueOrder).ToList();
truckOnQueueViewModel = Mapper.Map <IEnumerable <QueueList>, IEnumerable <QueueListViewModel> >(queryResult);
response = ResponseConstructor <QueueListViewModel> .ConstructEnumerableData(ResponseCode.SUCCESS, truckOnQueueViewModel);
break;
case TRUCK_CONDITION_3XXX_WAITING_CALL:
queryResult = (await _queueListRepository.GetManyAsync(c =>
c.isDelete == false &&
(
c.gatePass.state.ID == GatepassState.STATE_REGISTERED
) &&
c.gatePass.truckGroup.Code == TruckGroups.GROUP_3XXX,
QueryIncludes.SECURITY_QUEUE_INCLUDES)
).ToArray().OrderBy(q => q.queueOrder).ToList();
truckOnQueueViewModel = Mapper.Map <IEnumerable <QueueList>, IEnumerable <QueueListViewModel> >(queryResult);
response = ResponseConstructor <QueueListViewModel> .ConstructEnumerableData(ResponseCode.SUCCESS, truckOnQueueViewModel);
break;
default:
response = ResponseConstructor <QueueListViewModel> .ConstructEnumerableData(ResponseCode.ERR_SEC_NOT_SUPPORT_CONDITION, null);
break;
}
}
return(response);
}
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> > RegisterSecurityCheck(string rfidCode)
{
ResponseViewModel <GatePassViewModel> response;
GatePass queryGatePassResult;
GatePassViewModel GatePassViewModel;
RFIDCard queryRfidResult;
int tmpResponseCode;
if (_unitOfWork.Exists() == false)
{
// Cound Not Connect to Database
response = ResponseConstructor <GatePassViewModel> .ConstructData(ResponseCode.ERR_DB_CONNECTION_FAILED, null);
}
else
{
// Find RFID
queryRfidResult = await _rfidCardRepository.GetAsync(r => r.isDelete == false && r.code == rfidCode);
if (queryRfidResult == null)
{
// Not found RFID card ID
response = ResponseConstructor <GatePassViewModel> .ConstructData(ResponseCode.ERR_SEC_NOT_FOUND_RFID, null);
}
else
{
// Find GatePass
queryGatePassResult = await _gatePassRepository.GetAsync(
g => g.isDelete == false &&
g.RFIDCardID == queryRfidResult.ID, QueryIncludes.SECURITY_GATEPASS_INCLUDES);
if (queryGatePassResult == null)
{
// Not Found Gatepass matched with RFID No
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
{
// Check Truck state and Update its
switch (queryGatePassResult.state.ID)
{
case GatepassState.STATE_CALLING_1:
case GatepassState.STATE_CALLING_2:
case GatepassState.STATE_CALLING_3:
tmpResponseCode = ResponseCode.SUCCESS;
break;
case GatepassState.STATE_FINISH_WEIGHT_OUT: //STATE_WEIGHT_OUT:
tmpResponseCode = ResponseCode.SUCCESS;
break;
default:
tmpResponseCode = ResponseCode.ERR_SEC_NOT_PERMITTED_REG;
break;
}
GatePassViewModel = Mapper.Map <GatePass, GatePassViewModel>(queryGatePassResult);
// Return gatepass/truck
response = ResponseConstructor <GatePassViewModel> .ConstructData(tmpResponseCode, GatePassViewModel);
}
}
}
return(response);
}
public async Task <ResponseViewModel <QueueListViewModel> > CallNextTruck(int truckGroupID)
{
ResponseViewModel <QueueListViewModel> response = new ResponseViewModel <QueueListViewModel>();
var queues = await _queueListRepository.GetManyAsync(qu => qu.gatePass.truckGroupID == truckGroupID && qu.isDelete == false, QueryIncludes.QUEUELISTFULLINCLUDES);
var firstqueue = queues.OrderBy(q => q.queueNumber).First();
var gatePass = await _gatePassRepository.GetAsync(gt => gt.ID == firstqueue.gatePassID && gt.isDelete == false, QueryIncludes.GATEPASSFULLINCLUDES);
if (gatePass == null)
{
response = ResponseConstructor <QueueListViewModel> .ConstructBoolRes(ResponseCode.ERR_QUE_NO_QUEUE_FOUND, false);
}
else
{
// Change GatePass state
switch (gatePass.stateID)
{
case GatepassState.STATE_REGISTERED:
gatePass.stateID = GatepassState.STATE_CALLING_1;
break;
case GatepassState.STATE_CALLING_1:
gatePass.stateID = GatepassState.STATE_CALLING_2;
break;
case GatepassState.STATE_CALLING_2:
gatePass.stateID = GatepassState.STATE_CALLING_3;
break;
case GatepassState.STATE_CALLING_3:
// Update state & Update queueList
gatePass.stateID = GatepassState.STATE_REGISTERED;
var currentQueue = await _queueListRepository.GetAsync(qu => qu.gatePassID == gatePass.ID && qu.isDelete == false);
var queueList = await _queueListRepository.GetManyAsync(qu => qu.queueNumber > currentQueue.queueNumber && qu.queueNumber <= (currentQueue.queueNumber + 5) && qu.gatePass.truckGroup.ID == gatePass.truckGroup.ID && qu.isDelete == false);
// If there are less than 5 - move to the last
if (queueList.Count() < 5)
{
// Set new Order
currentQueue.queueNumber += queueList.Count();
// Shift up 1 item for orther QueueItem
foreach (var queueItem in queueList)
{
queueItem.queueNumber -= 1;
_queueListRepository.Update(queueItem);
}
}
else // If more than 5 - move down 5
{
// Set new order
currentQueue.queueNumber += 5;
// Shift up 1 item for orther QueueItem
foreach (var queueItem in queueList)
{
queueItem.queueNumber -= 1;
_queueListRepository.Update(queueItem);
}
}
break;
default:
return(response = ResponseConstructor <QueueListViewModel> .ConstructBoolRes(ResponseCode.ERR_QUE_NO_QUEUE_FOUND, false));
}
_gatePassRepository.Update(gatePass);
if (await _unitOfWork.SaveChangesAsync())
{
response = ResponseConstructor <QueueListViewModel> .ConstructBoolRes(ResponseCode.SUCCESS, true);
}
else
{
response = ResponseConstructor <QueueListViewModel> .ConstructBoolRes(ResponseCode.ERR_SEC_UNKNOW, false);
}
}
return(response);
}
