private async void CtrcChangedCommandHandler()
{
if (Model.Number.IsInt() &&
!string.IsNullOrEmpty(Model.Digit) &&
Model.UnitEmission.IsInt())
{
await _popupNavigation.PushAsync(new LoadingPopupPage());
var billOfLadingCollectorView = await _billOfLadingService.GetBillOfLading(Model.Number.ToInt(), Model.Digit, Model.UnitEmission);
await _popupNavigation.PopAllAsync();
Model.BillOfLadingCollectorViewInfo = billOfLadingCollectorView.Response;
if (Model.BillOfLadingCollectorViewInfo != null)
{
Model.PackAmount = Model.BillOfLadingCollectorViewInfo.PackAmount.ToString();
Model.NumberIsReadOnly = Model.DigitIsReadOnly = Model.UnitEmissionIsReadOnly = true;
Model.PackIsReadOnly = false;
Model.PackFocus();
AddMenuAdtionalBunttons();
}
else
{
await _notificationService.NotifyAsync("CTRC inválido.", SoundEnum.Erros);
}
}
else
{
Model.BillOfLadingCollectorViewInfo = null;
MenuAdtionalButtons = new Dictionary <string, DelegateCommand>();
}
}
private async Task <IEnumerable <PackingListDetailViewInfoModel> > GetViewLack()
{
await _popupNavigation.PushAsync(new LoadingPopupPage());
switch (Model.LackType)
{
case LackTypeEnum.Boarding:
var getViewLackBoardingByTrafficScheduleDetail =
await _boardingService.GetViewLackBoardingByTrafficScheduleDetail(Model.PackingListId, _userService.User.Unit.Id, Model.VehicleViewInfo.TrafficScheduleDetailId);
await _popupNavigation.PopAllAsync();
return(getViewLackBoardingByTrafficScheduleDetail.Response);
case LackTypeEnum.Landing:
var getViewLackLandingByTrafficScheduleDetail =
await _landingService.GetViewLackLandingByTrafficScheduleDetail(Model.VehicleViewInfo.TrafficScheduleDetailId);
await _popupNavigation.PopAllAsync();
return(getViewLackLandingByTrafficScheduleDetail.Response);
default:
await _popupNavigation.PopAllAsync();
return(new List <PackingListDetailViewInfoModel>());
}
}
private async void GetPackingListDelivery()
{
if (Model.CheckOutDate.HasValue &&
!string.IsNullOrEmpty(Model.Line) &&
!string.IsNullOrEmpty(Model.Driver) &&
!string.IsNullOrEmpty(Model.Vehicle))
{
await _popupNavigation.PushAsync(new LoadingPopupPage());
var packingListViewInfo = await _boardingDeliveryPackService.GetPackingListDelivery(
new GetPackingListDeliveryModel(_userService.User.Unit.Id, Model.CheckOutDate.Value.ToString("dd/MM/yyyy HH:mm"),
Model.LineInfoView.Id, Model.VehicleViewInfo.Id, Model.DriverInfoView.Id,
_wifiService.MacAddress, true));
await _popupNavigation.PopAllAsync();
if (packingListViewInfo.Response != null &&
packingListViewInfo.Response.Id > 0 &&
packingListViewInfo.Response.Valid &&
packingListViewInfo.Response.ExceptionCode == ExceptionCodeEnum.NoError)
{
SetPackingListDelivery(packingListViewInfo.Response);
}
else if (packingListViewInfo.Response != null)
{
switch (packingListViewInfo.Response.ExceptionCode)
{
case ExceptionCodeEnum.ExistsPackinglistDelivery:
if (await _notificationService.AskQuestionAsync(
"Existe outro romaneio aberto com essas configurações.\nDeseja utilizá-lo?", SoundEnum.Alert))
{
SetPackingListDelivery(packingListViewInfo.Response);
}
else
{
Model.PackingListViewInfo = null;
Model.ClearModelAfterDriver();
await _notificationService.NotifyAsync("Operação cancelada.", SoundEnum.Alert);
}
break;
default:
Model.PackingListViewInfo = null;
Model.ClearModelAfterDriver();
await _notificationService.NotifyAsync(packingListViewInfo.Response.ExceptionMessage, SoundEnum.Erros);
break;
}
}
}
else
{
Model.PackingListViewInfo = null;
Model.ClearModelAfterVehicle();
}
}
public async Task <bool> ShowConfirmationDialogAsync(string message, string yesButtonText = "Yes", string noButtonText = "No")
{
var confirmationDialog = new ConfirmationDialog(message)
{
YesButtonText = yesButtonText,
NoButtonText = noButtonText
};
await _popupNavigation.PushAsync(confirmationDialog);
var result = await confirmationDialog.GetResult();
await _popupNavigation.PopAllAsync();
return((bool)result);
}
private async void ConfirmationCommandHandler()
{
if (Model.BillOfLadingPackLvItems.Any(item => item.Checked))
{
if (await _notificationService.AskQuestionAsync(
"Confirma solicitação de impressão do(s) volume(s) selecionado(s)?", SoundEnum.Alert))
{
await _popupNavigation.PushAsync(new LoadingPopupPage());
var result = await _billOfLadingService.SendListBillOfLadingPack(
new SendListBillOfLadingPackModel(_wifiService.MacAddress,
Model.BillOfLadingPackLvItems.Where(item => item.Checked)
.Select(item => item.BillOfLadingPack.Id.ToString())));
await _popupNavigation.PopAllAsync();
if (result.IsSuccessStatusCode)
{
await _notificationService.NotifyAsync("Solicitação enviada com sucesso.", SoundEnum.Alert);
await NavigationService.GoBackAsync();
}
}
}
else
{
await _notificationService.NotifyAsync("Selecione ao menos um volume.", SoundEnum.Erros);
}
}
public static async Task PopAllPopupAsyncSafe(this INavigation sender, IPopupNavigation popupNavigation, bool animate = true)
{
if (Device.RuntimePlatform == "Test")
{
return;
}
await popupNavigation.PopAllAsync(animate);
}
private async Task SetPackingListLanding()
{
await _popupNavigation.PushAsync(new LoadingPopupPage());
var getLandingByTrafficScheduleId = await _landingService.GetLandingByTrafficScheduleId(
_userService.User.Unit.Id, _userService.User.Unit.Code, Model.CarNumber, Model.TeamViewInfo.Id);
await _popupNavigation.PopAllAsync();
if (getLandingByTrafficScheduleId.Response != null && getLandingByTrafficScheduleId.Response.Valid)
{
Model.VehicleViewInfo = getLandingByTrafficScheduleId.Response;
SetVehicleLanding();
}
else
{
MenuAdtionalButtons = new Dictionary <string, DelegateCommand>();
}
}
private async void ReadingByUniversalLanding()
{
await _popupNavigation.PushAsync(new LoadingPopupPage());
var packingListDetailViewInfo = await _sorterService.ReadingByUniversalLanding(new ReadingByUniversalLandingModel(Model.Reading, _userService.User.Unit.Id, _wifiService.MacAddress));
await _popupNavigation.PopAllAsync();
if (packingListDetailViewInfo.Response != null && !packingListDetailViewInfo.Response.Valid)
{
await _notificationService.NotifyAsync(packingListDetailViewInfo.Response.ExceptionMessage, SoundEnum.Erros);
}
else if (packingListDetailViewInfo.Response == null)
{
await _notificationService.NotifyAsync("Falha ao realizar processo de desembarque universal.", SoundEnum.Erros);
}
Model.ClearModel();
Model.ReadingFocus();
}
private void EnableWifi()
{
Task.Run(async() =>
{
if (!_wifiService.IsEnabled)
{
await Task.Delay(TimeSpan.FromSeconds(1));
await _popupNavigation.PushAsync(new LoadingPopupPage());
_wifiService.Enable();
await Task.Delay(TimeSpan.FromSeconds(5));
_tmsApiServiceBase.SetApiUrl(_environmentConfigurationService.Configuration.ApiUrls);
await Task.Delay(TimeSpan.FromSeconds(2));
await _popupNavigation.PopAllAsync();
}
SetLabelsDescription();
});
}
private async void ConfirmationCommandHandler()
{
if (!string.IsNullOrEmpty(Model.Reading))
{
await _popupNavigation.PushAsync(new LoadingPopupPage());
var getBillOfLadingInformationsByBarCode = await _billOfLadingService.GetBillOfLadingInformationsByBarCode(Model.Reading);
await _popupNavigation.PopAllAsync();
if (getBillOfLadingInformationsByBarCode.Response?.BillOfLadingInformations != null &&
getBillOfLadingInformationsByBarCode.Response.BillOfLadingInformations.Any())
{
var informations = getBillOfLadingInformationsByBarCode.Response.BillOfLadingInformations.ToArray();
Model.Cte = informations[0].ToString() + "-" + informations[1].ToString();
Model.Origim = informations[2].ToString();
Model.Destination = informations[3].ToString();
Model.Invoice = informations[4].ToString();
Model.Vol = informations[5].ToString();
Model.WeightVol = informations[6].ToString() + " kg";
Model.TotalVolume = informations[7].ToString();
Model.TotalBaseWeight = informations[8].ToString() + " kg";
Model.TotalRealWeight = informations[9].ToString() + " kg";
Model.TotalWeightCubicated = informations[10].ToString() + " kg";
Model.ReadingIsReadOnly = true;
}
else
{
Model.Reading = String.Empty;
await _notificationService.NotifyAsync("Código de barras não encontrado.",
SoundEnum.Erros);
Model.ReadingFocus();
}
}
else
{
await _notificationService.NotifyAsync("Realize a leitura do código de barras.", SoundEnum.Alert);
}
}
private async void LoadSeals()
{
await _popupNavigation.PushAsync(new LoadingPopupPage());
var getSeals = await _boardingAccessoryService.GetSeals(Model.PackingListAccessoryId);
await _popupNavigation.PopAllAsync();
if (getSeals.Response != null && getSeals.Response.Seals.Any())
{
Model.Seals = new ObservableCollection <string>(getSeals.Response.Seals);
}
if (!Model.OnlyConference)
{
Model.LvSeals = new ObservableCollection <string>(Model.Seals);
}
}
private async void ExecuteClosePackingListAccessory(ValidClosePackingListAccessoryModel model)
{
await _popupNavigation.PushAsync(new LoadingPopupPage());
var packingListViewInfo = await _boardingAccessoryService.ValidClosePackingListAccessory(model);
if (packingListViewInfo.Response != null && packingListViewInfo.Response.Valid)
{
packingListViewInfo =
await _boardingAccessoryService.ClosePackingListAccessory(Model.PackingListViewInfo.Id,
new MacAddressModel(_wifiService.MacAddress));
await _popupNavigation.PopAllAsync();
if (packingListViewInfo.Response != null && packingListViewInfo.Response.Valid)
{
await _notificationService.NotifyAsync("Romaneio fechado.", SoundEnum.Alert);
await NavigationService.GoBackAsync();
}
else
{
var msg = ((packingListViewInfo.Response != null && !packingListViewInfo.Response.Valid)
? packingListViewInfo.Response.ExceptionMessage
: "Não foi possivel completar a requisição.");
await _notificationService.NotifyAsync(msg, SoundEnum.Erros);
}
}
else if (packingListViewInfo.Response != null && !packingListViewInfo.Response.Valid)
{
await _popupNavigation.PopAllAsync();
switch (packingListViewInfo.Response.ExceptionCode)
{
case ExceptionCodeEnum.ExistsPacksUnread:
await _notificationService.NotifyAsync(packingListViewInfo.Response.ExceptionMessage, SoundEnum.Alert);
var ignoreBillOfLadings = model.IgnoreBillOfLadings.ToList();
ignoreBillOfLadings.Add(packingListViewInfo.Response.BillOfLadingId);
ClosePackingListAccessory(new ValidClosePackingListAccessoryModel(model.PackingListAccessoryId,
model.IgnoreAmountSealsSuperior, ignoreBillOfLadings, model.MacAddress));
break;
case ExceptionCodeEnum.AmountSealsInferior:
if (await _notificationService.AskQuestionAsync(packingListViewInfo.Response.ExceptionMessage,
SoundEnum.Alert))
{
await NavigationService.NavigateAsync("MaintenanceSealsInputPage",
new NavigationParameters()
{
{ "Title", "Solicitação" },
{
"MaintenanceSealsInputModel",
new MaintenanceSealsInputModel()
{
OnlyConference = false,
PackingListAccessoryId = model.PackingListAccessoryId,
TransportAccessoryDoors = packingListViewInfo.Response.TransportAccessoryDoors
}
},
{ "CallBackData", new Dictionary <string, object>()
{
{ "Model", model }
} }
}
);
}
break;
case ExceptionCodeEnum.PackinglistAccessoryEmpty:
await _notificationService.NotifyAsync(packingListViewInfo.Response.ExceptionMessage, SoundEnum.Alert);
packingListViewInfo = await _boardingAccessoryService.DeletePackingListAccessory(Model.PackingListViewInfo.Id);
if (packingListViewInfo.Response != null && !packingListViewInfo.Response.Valid)
{
await _notificationService.NotifyAsync(packingListViewInfo.Response.ExceptionMessage, SoundEnum.Erros);
}
break;
default:
await _notificationService.NotifyAsync(packingListViewInfo.Response.ExceptionMessage, SoundEnum.Erros);
break;
}
}
else
{
await _popupNavigation.PopAllAsync();
await _notificationService.NotifyAsync("A requisição não pode ser completada.", SoundEnum.Erros);
}
}
public virtual async Task PopAllAsync()
{
await _popupNavigation.PopAllAsync().ConfigureAwait(false);
}
private async void SetPackingListView(PackingListViewInfoModel packingListViewInfo)
{
Model.PackingListViewInfo = packingListViewInfo;
if (packingListViewInfo != null && packingListViewInfo.Valid)
{
await _popupNavigation.PushAsync(new LoadingPopupPage());
Model.BolAmountView = packingListViewInfo.TotalBillOfLading.ToString();
Model.PacksAmountView = packingListViewInfo.TotalPack.ToString();
Model.PackingListNumber = packingListViewInfo.Number.ToString();
Model.PackingListDigit = packingListViewInfo.Digit.ToString();
if (DateTime.TryParse(packingListViewInfo.TrafficScheduleDetailCheckoutDate, out DateTime checkOutDate))
{
Model.Date = checkOutDate.ToString("dd/MM/yyyy");
Model.Time = checkOutDate.ToString("HH:mm");
}
var driverAndVehicle =
await _landingDeliveryPackService.GetDriverAndVehicle(packingListViewInfo.Id);
if (driverAndVehicle.Response?.DriverAndVehicle != null &&
driverAndVehicle.Response.DriverAndVehicle.Count() == 2)
{
Model.Driver = driverAndVehicle.Response.DriverAndVehicle.FirstOrDefault();
Model.Vehicle = driverAndVehicle.Response.DriverAndVehicle.LastOrDefault();
var driverInfoView = await _boardingDeliveryPackService.ValidDriver(Model.Driver.ToInt());
var vehicleViewInfo = await _commonService.ValidVehicle(Model.Vehicle);
Model.DriverInfoView = driverInfoView.Response;
Model.VehicleViewInfo = vehicleViewInfo.Response;
if (driverInfoView.Response != null)
{
Model.DriverDescription = driverInfoView.Response.Descritpion;
}
if (vehicleViewInfo.Response != null)
{
Model.VehicleView = vehicleViewInfo.Response.Plate;
}
}
await _popupNavigation.PopAllAsync();
if (packingListViewInfo.TotalBillOfLading == 0)
{
await _notificationService.NotifyAsync("Não houve nenhum motivo de não entrega para esse romaneio. Por isso não há retornos.", SoundEnum.Alert);
}
Model.PackingListNumberIsReadOnly = Model.PackingListDigitIsReadOnly = Model.DateIsReadOnly =
Model.TimeIsReadOnly = Model.DriverIsReadOnly = Model.VehicleIsReadOnly = true;
Model.Reading = String.Empty;
Model.ReadingIsReadOnly = false;
Model.ReadingFocus();
}
else if (packingListViewInfo != null)
{
await _notificationService.NotifyAsync(packingListViewInfo.ExceptionMessage, SoundEnum.Erros);
}
}
/// <summary>
/// Pop from popup stack.
/// </summary>
/// <param name="all"></param>
/// <returns></returns>
public Task Pop(bool all = false)
{
return(all ? popupNavigation.PopAllAsync() : popupNavigation.PopAsync());
}
public async Task PopAsync()
{
await Popup.PopAllAsync();
}
/// <inheritdoc/>
public IObservable<Unit> PopAllPopups(bool animate = true) =>
Observable
.FromAsync(() => _popupNavigation.PopAllAsync(animate))
.Do(_ => PopRootAndTick(PopupSubject, NavigationDisposables));
