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 <UserAccessData> AuthenticateUser(UserAccessData loginInfo)
{
if (loginInfo != null)
{
UserAccessData result = userRepo.UserLogin(loginInfo);
if (result.UserName != null)
{
response = new ResponseMessageData <UserAccessData>()
{
Data = result,
Message = "Success"
};
}
else
{
response = new ResponseMessageData <UserAccessData>()
{
Data = null,
Message = "NoUserFound"
};
}
return(response);
}
else
{
response = new ResponseMessageData <UserAccessData>()
{
Data = null,
Message = "NoData"
};
return(response);
}
}
public void GetPreparationTime(string wsAddress, ResponseMessageData <StoreModel> response)
{
using (var client = new CustomerOrderClient(new BasicHttpBinding(), new EndpointAddress(wsAddress + SettingsData.Constants.StoreOrder.WsCustomerOrder)))
{
var iTries = 0;
while (iTries < 3)
{
try
{
var result = client.GetPreparationTime();
if (response.IsSuccess)
{
response.IsSuccess = true;
response.Message = String.Format("Entrega {0} mins", result.PrepTime);
return;
}
response.IsSuccess = false;
response.Message = result.ExcMsg;
return;
}
catch (Exception ex)
{
SharedLogger.LogError(ex);
}
Thread.Sleep(new Random().Next(50, 300));
iTries++;
}
client.Close();
response.IsSuccess = false;
response.Message = "No fue posible comunicarse a la sucursal para obtener el tiempo de preparación ";
}
}
public StoreModel StoreAvailableByStore(ItemCatalog item, ResponseMessageData <StoreModel> response)
{
using (_repositoryStore)
{
var store = _repositoryStore.GetStoreById(item.Id);
return(GetStoreAvailable(response, new List <StoreModel> {
store
}, false));
}
}
public StoreModel StoreAvailableForAddress(StoreAvailableModel model, ResponseMessageData <StoreModel> response)
{
using (_repositoryStore)
{
int franchiseId;
var stores = FactoryAddress.GetQueryToSearchStore(_repositoryStore.InnerDbEntities, model.FranchiseCode,
model.AddressInfo, out franchiseId);
return(GetStoreAvailable(response, stores, true));
}
}
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 <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 <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 <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 <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 <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 <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 <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 <OrderModelDto> SendOrderToStore(OrderModelDto model, IHubCallerConnectionContext <dynamic> clients)
{
var responseCod = new AccountService().IsValidInfoServer();
var response = responseCod.DeserializeAndDecrypt <ConnectionInfoResponse>();
var resMsg = new ResponseMessageData <OrderModelDto>();
if (response.NxWn != SharedConstants.Client.STATUS_SCREEN_LOGIN)
{
resMsg.IsSuccess = false;
resMsg.Message = response.Msg;
return(resMsg);
}
using (_repositoryStore)
{
var store = model.Store;
//var store = FactoryAddress.GetQueryToSearchStore(_repositoryStore.InnerDbEntities, model.FranchiseCode, model.AddressInfo, out franchiseId);
//TODO Falta verificar si tiene la capacidad para albergar una orden más
if (store == null || store.IdKey.HasValue == false)
{
resMsg.IsSuccess = false;
resMsg.Message = "No se encontró una sucursal cercana a este domicilio, por favor reporte a soporte técnico";
return(resMsg);
}
var franchiseId = _repositoryStore.GetFranchiseIdByStoreId((int)store.IdKey.Value);
model.Store = store;
model.FranchiseId = franchiseId;
model.UserId = AccountRepository.GetIdByUsername(model.Username, _repositoryStore.InnerDbEntities);
_repositoryStore.SaveOrderToStore(model);
var offline = _repositoryStore.IsStoreOnline((int)store.IdKey.Value, DateTime.UtcNow);
if (offline != null)
{
resMsg.IsSuccess = false;
resMsg.Message = GetMessageStoreOffline(offline, store);
return(resMsg);
}
}
Task.Run(() => SendOrderToStoreEvent(model, clients));
resMsg.Data = model;
resMsg.IsSuccess = true;
return(resMsg);
}
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 <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 <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 <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 <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 <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 <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 <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 <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 <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 <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"));
}
}
