public ResponseMessageData <StoreModel> StoreAvailableForAddress(StoreAvailableModel model)
{
try
{
var response = new ResponseMessageData <StoreModel>();
if (model.AddressInfo.IsMap == false)
{
AppInit.Container.Resolve <IStoreService>().StoreAvailableForAddress(model, response);
}
else
{
AppInit.Container.Resolve <IStoreService>().StoreAvailableForAddressMap(model, response);
}
if (response.IsSuccess == false)
{
return(response);
}
return(response);
}
catch (Exception ex)
{
SharedLogger.LogError(ex);
return(ResponseMessageData <StoreModel> .CreateCriticalMessage("No fue posible obtener una sucursal disponible para esa dirección"));
}
}
public ResponseMessageData <LastOrderInfoModel> LastNthOrdersByPhone(String phone)
{
try
{
return(AppInit.Container.Resolve <IOrderService>().LastNthOrdersByPhone(phone));
}
catch (Exception ex)
{
SharedLogger.LogError(ex);
return(ResponseMessageData <LastOrderInfoModel> .CreateCriticalMessage("No fue posible obtener la última orden"));
}
}
public ResponseMessageData <PhoneModel> SavePhone(PhoneModel model)
{
try
{
return(AppInit.Container.Resolve <IOrderService>().SavePhone(model));
}
catch (Exception ex)
{
SharedLogger.LogError(ex);
return(ResponseMessageData <PhoneModel> .CreateCriticalMessage("No fue posible almacenar el número telefónico"));
}
}
public ResponseMessageData <AddressInfoModel> SaveClient(AddressInfoModel model)
{
try
{
return(AppInit.Container.Resolve <IAddressService>().SaveAddress(model));
}
catch (Exception ex)
{
SharedLogger.LogError(ex);
return(ResponseMessageData <AddressInfoModel> .CreateCriticalMessage("No fue posible guardar el cliente"));
}
}
public ResponseMessageData <RecurrenceResponseModel> CalculateRecurrence(List <long> lstClientId)
{
try
{
return(AppInit.Container.Resolve <IClientService>().CalculateRecurrence(lstClientId));
}
catch (Exception ex)
{
SharedLogger.LogError(ex);
return(ResponseMessageData <RecurrenceResponseModel> .CreateCriticalMessage("No fue posible calcular la recurrencia del cliente"));
}
}
public ResponseMessageData <PropagateOrderModel> PosOrderByOrderToStoreId(long orderToStoreId)
{
try
{
return(AppInit.Container.Resolve <IOrderService>().PosOrderByOrderToStoreId(orderToStoreId));
}
catch (Exception ex)
{
SharedLogger.LogError(ex);
return(ResponseMessageData <PropagateOrderModel> .CreateCriticalMessage("No fue posible obtener la última orden"));
}
}
public ResponseMessageData <bool> RemoveRelPhoneAddress(AddressPhoneModel model)
{
try
{
return(AppInit.Container.Resolve <IOrderService>().RemoveRelPhoneAddress(model));
}
catch (Exception ex)
{
SharedLogger.LogError(ex);
return(ResponseMessageData <bool> .CreateCriticalMessage("No fue posible eliminar la relación teléfono-dirección"));
}
}
public ResponseMessageData <PosCheck> CalculatePrices(String phone)
{
try
{
return(AppInit.Container.Resolve <IOrderService>().CalculatePrices(phone));
}
catch (Exception ex)
{
SharedLogger.LogError(ex);
return(ResponseMessageData <PosCheck> .CreateCriticalMessage("No fue posible calcular el costo del pedido"));
}
}
public ResponseMessageData <OrderModelDto> SendOrderToStore(OrderModelDto model)
{
try
{
return(AppInit.Container.Resolve <IStoreService>().SendOrderToStore(model, Clients));
}
catch (Exception ex)
{
SharedLogger.LogError(ex);
return(ResponseMessageData <OrderModelDto> .CreateCriticalMessage("No fue posible enviar la orden a la sucursal"));
}
}
public ResponseMessageData <ClientInfoModel> SaveClient(ClientInfoModel model)
{
try
{
return(AppInit.Container.Resolve <IOrderService>().SaveClient(model));
}
catch (Exception ex)
{
SharedLogger.LogError(ex);
return(ResponseMessageData <ClientInfoModel> .CreateCriticalMessage("No fue posible almacenar los datos del cliente"));
}
}
public ResponseMessageData <PosCheck> SavePosCheck(PosCheck model)
{
try
{
return(AppInit.Container.Resolve <IOrderService>().SavePosCheck(model));
}
catch (Exception ex)
{
SharedLogger.LogError(ex);
return(ResponseMessageData <PosCheck> .CreateCriticalMessage("No fue posible almacenar la orden del POS"));
}
}
public ResponseMessageData <ListItemModel> SearchByZipCode(String zipCode)
{
try
{
return(new ResponseMessageData <ListItemModel>
{
IsSuccess = true,
LstData = AppInit.Container.Resolve <IAddressService>().SearchByZipCode(zipCode)
});
}
catch (Exception ex)
{
SharedLogger.LogError(ex);
return(ResponseMessageData <ListItemModel> .CreateCriticalMessage("No fue posible determinar la dirección con el código postal"));
}
}
public ResponseMessageData <ListItemModel> SearchClientsByClientName(String clientName)
{
try
{
return(new ResponseMessageData <ListItemModel>
{
IsSuccess = true,
LstData = AppInit.Container.Resolve <IClientService>().SearchClientsByClientName(clientName)
});
}
catch (Exception ex)
{
SharedLogger.LogError(ex);
return(ResponseMessageData <ListItemModel> .CreateCriticalMessage("No fue posible listar los clientes por su nombre"));
}
}
public ResponseMessageData <SyncFranchiseModel> GetListSyncFiles()
{
try
{
return(new ResponseMessageData <SyncFranchiseModel>
{
IsSuccess = true,
LstData = AppInit.Container.Resolve <IFranchiseService>().GetListSyncFiles(Context.Headers[SharedConstants.Server.USERNAME_HEADER])
});
}
catch (Exception ex)
{
SharedLogger.LogError(ex);
return(ResponseMessageData <SyncFranchiseModel> .CreateCriticalMessage("No fue posible obtener los archivos a sincronizar"));
}
}
public ResponseMessageData <ButtonItemModel> GetMenuByUser(String username)
{
try
{
return(new ResponseMessageData <ButtonItemModel>
{
IsSuccess = true,
LstData = AppInit.Container.Resolve <IAccountService>().GetMenuByUser(username)
});
}
catch (Exception ex)
{
SharedLogger.LogError(ex);
return(ResponseMessageData <ButtonItemModel> .CreateCriticalMessage("No hay menú disponible"));
}
}
public ResponseMessageData <ListItemModel> SearchByCompany(String company)
{
try
{
return(new ResponseMessageData <ListItemModel>
{
IsSuccess = true,
LstData = AppInit.Container.Resolve <IClientService>().SearchByCompany(company)
});
}
catch (Exception ex)
{
SharedLogger.LogError(ex);
return(ResponseMessageData <ListItemModel> .CreateCriticalMessage("No fue posible buscar por compañía"));
}
}
public ResponseMessageData <ResponseMessage> CancelOrder(long orderToStoreId)
{
try
{
return(new ResponseMessageData <ResponseMessage>
{
IsSuccess = true,
Data = AppInit.Container.Resolve <IStoreService>().CancelOrder(orderToStoreId),
});
}
catch (Exception ex)
{
SharedLogger.LogError(ex);
return(ResponseMessageData <ResponseMessage> .CreateCriticalMessage("No fue posible cancelar la orden"));
}
}
public ResponseMessageData <AddressInfoModel> SearchAddressByPhone(String phone)
{
try
{
return(new ResponseMessageData <AddressInfoModel>
{
IsSuccess = true,
LstData = AppInit.Container.Resolve <IAddressService>().SearchAddressByPhone(phone)
});
}
catch (Exception ex)
{
SharedLogger.LogError(ex);
return(ResponseMessageData <AddressInfoModel> .CreateCriticalMessage("No fue posible buscar una dirección por el teléfono"));
}
}
public ResponseMessageData <TrackOrderDto> ShowDetailByOrderId(long orderId)
{
try
{
return(new ResponseMessageData <TrackOrderDto>
{
IsSuccess = true,
Data = AppInit.Container.Resolve <ITrackService>().ShowDetailByOrderId(orderId)
});
}
catch (Exception ex)
{
SharedLogger.LogError(ex);
return(ResponseMessageData <TrackOrderDto> .CreateCriticalMessage("No fue posible rastrear el detalle de la orden"));
}
}
public ResponseMessageData <ClientInfoModel> SearchClientsByPhone(String phone)
{
try
{
return(new ResponseMessageData <ClientInfoModel>
{
IsSuccess = true,
LstData = AppInit.Container.Resolve <IClientService>().SearchClientsByPhone(phone)
});
}
catch (Exception ex)
{
SharedLogger.LogError(ex);
return(ResponseMessageData <ClientInfoModel> .CreateCriticalMessage("No fue posible listar los clientes por el teléfono"));
}
}
public ResponseMessageData <StoreNotificationCategoryModel> GetNotificationsByStore(int storeId)
{
try
{
var response = new ResponseMessageData <StoreNotificationCategoryModel>
{
IsSuccess = true,
LstData = AppInit.Container.Resolve <IStoreService>().GetNotificationsByStore(storeId)
};
return(response);
}
catch (Exception ex)
{
SharedLogger.LogError(ex);
return(ResponseMessageData <StoreNotificationCategoryModel> .CreateCriticalMessage("No fue posible obtener las notificaciones para la sucursal seleccionada"));
}
}
public ResponseMessageData <TrackOrderDto> SearchByDailyInfo(PagerDto <DailySearchModel> model)
{
try
{
return(new ResponseMessageData <TrackOrderDto>
{
IsSuccess = true,
LstData = AppInit.Container.Resolve <ITrackService>().SearchByDailyInfo(model),
Pager = model.Pager
});
}
catch (Exception ex)
{
SharedLogger.LogError(ex);
return(ResponseMessageData <TrackOrderDto> .CreateCriticalMessage("No fue posible obtener los pedidos con esos parámetros"));
}
}
public ResponseMessageData <TrackOrderDto> SearchByClientName(PagerDto <long> client)
{
try
{
return(new ResponseMessageData <TrackOrderDto>
{
IsSuccess = true,
LstData = AppInit.Container.Resolve <ITrackService>().SearchByClient(client),
Pager = client.Pager
});
}
catch (Exception ex)
{
SharedLogger.LogError(ex);
return(ResponseMessageData <TrackOrderDto> .CreateCriticalMessage("No fue posible rastrear por nombre del cliente"));
}
}
public ResponseMessageData <string> GetAccountInfo()
{
try
{
return(new ResponseMessageData <string>
{
IsSuccess = true,
Data = AppInit.Container.Resolve <IAccountService>()
.GetAccountInfo(Context.Headers[SharedConstants.Server.USERNAME_HEADER], Context.Headers[SharedConstants.Server.CONNECTION_ID_HEADER])
});
}
catch (Exception ex)
{
SharedLogger.LogError(ex);
return(ResponseMessageData <string> .CreateCriticalMessage("No hay información disponible del usuario"));
}
}
public ResponseMessageData <bool> SendOrder(PosCheck posCheck)
{
try
{
MessageBus.Current.SendMessage(posCheck, SharedMessageConstants.ORDER_SEND_POSORDER);
return(new ResponseMessageData <bool>
{
IsSuccess = true
});
}
catch (Exception ex)
{
SharedLogger.LogError(ex);
return(ResponseMessageData <bool> .CreateCriticalMessage("No fue posible enviar la orden al POS"));
}
}
public ResponseMessageData <TrackOrderDto> SearchByPhone(PagerDto <String> phone)
{
try
{
var lstData = AppInit.Container.Resolve <ITrackService>().SearchByPhone(phone);
return(new ResponseMessageData <TrackOrderDto>
{
IsSuccess = true,
LstData = lstData,
Pager = phone.Pager
});
}
catch (Exception ex)
{
SharedLogger.LogError(ex);
return(ResponseMessageData <TrackOrderDto> .CreateCriticalMessage("No fue posible rastrear por número telefónico"));
}
}
public ResponseMessageData <ButtonItemModel> GetFranchiseButtons()
{
try
{
var lstData = AppInit.Container.Resolve <IFranchiseService>().GetFranchiseButtons();
return(new ResponseMessageData <ButtonItemModel>
{
IsSuccess = true,
LstData = lstData
});
}
catch (Exception ex)
{
SharedLogger.LogError(ex);
return(ResponseMessageData <ButtonItemModel> .CreateCriticalMessage("No fue posible obtener las franquicias a emplear"));
}
}
public ResponseMessageData <ListItemModel> FillNextListByName(AddressQuery addressQuery)
{
try
{
string sControlName;
var response = new ResponseMessageData <ListItemModel>
{
IsSuccess = true,
LstData = AppInit.Container.Resolve <IAddressService>().FillNextListByName(addressQuery.NextRegion, addressQuery.ItemSelId, out sControlName),
Message = sControlName
};
return(response);
}
catch (Exception ex)
{
SharedLogger.LogError(ex);
return(ResponseMessageData <ListItemModel> .CreateCriticalMessage("No fue posible determinar la siguiente región"));
}
}
public ResponseMessageData <StoreModel> StoreAvailableByStore(ItemCatalog item)
{
try
{
var response = new ResponseMessageData <StoreModel>();
var store = AppInit.Container.Resolve <IStoreService>().StoreAvailableByStore(item, response);
if (response.IsSuccess == false)
{
return(response);
}
AppInit.Container.Resolve <IStoreService>().GetPreparationTime(store.WsAddress, response);
return(response);
}
catch (Exception ex)
{
SharedLogger.LogError(ex);
return(ResponseMessageData <StoreModel> .CreateCriticalMessage("No fue posible obtener una sucursal disponible para esa dirección o selección"));
}
}
