public void SaveOrderToStore(OrderModelDto model)
{
var now = DateTime.Now;
var orderToStore = new OrderToStore
{
LastStatus = OrderStatus.NEW_READY_TO_SEND,
AddressId = model.AddressInfo.AddressId ?? SettingsData.Constants.Entities.NULL_ID_INT,
LastUpdate = now,
ClientPhoneId = model.PhoneId,
ClientId = model.ClientId ?? SettingsData.Constants.Entities.NULL_ID_INT,
FranchiseId = model.FranchiseId,
FranchiseStoreId = (int)(model.Store.IdKey ?? SettingsData.Constants.Entities.NULL_ID_INT),
PosOrderId = model.PosOrder.Id ?? SettingsData.Constants.Entities.NULL_ID_INT,
StartDatetime = now,
UserInsId = model.UserId,
PaymentId = model.OrderDetails.Payment.Id,
PosOrderStatus = model.OrderDetails.PosOrderStatus,
ExtraNotes = model.OrderDetails.ExtraNotes,
InputType = SettingsData.Constants.StoreOrder.INPUT_TYPE_DELIVERY
};
DbEntities.OrderToStore.Add(orderToStore);
SaveLogOrderToStore(orderToStore, "Se almacenó la información del pedido. Listo para el envío a la sucursal " + model.Store.Value, orderToStore.LastStatus, now);
DbEntities.SaveChanges();
model.OrderToStoreId = orderToStore.OrderToStoreId;
model.Status = orderToStore.LastStatus;
}
private bool StoreIsAlive(OrderModelDto model)
{
var iTries = 2;
using (var client = new CustomerOrderClient(new BasicHttpBinding(), new EndpointAddress(model.Store.WsAddress + SettingsData.Constants.StoreOrder.WsCustomerOrder)))
{
while (iTries > 0)
{
try
{
var result = client.Ping();
if (result == SettingsData.Constants.StoreConst.STORE_RESPONSE_PING_WS_OK)
{
return(true);
}
iTries--;
}
catch (Exception)
{
iTries--;
}
}
client.Close();
}
return(false);
}
public void OnSendOrderToStoreStatusChanged(OrderModelDto model)
{
if (model.HasError)
{
ErrorMsg = model.Message;
HasSuccess = Visibility.Collapsed;
HasError = Visibility.Visible;
IsReadyToSend = Visibility.Visible;
IsSending = Visibility.Collapsed;
}
else
{
if (model.IsAlreadyOnStore)
{
HasSuccess = Visibility.Visible;
SuccessMsg = model.Message;
IsSending = Visibility.Collapsed;
}
else
{
HasSuccess = Visibility.Collapsed;
EventsMsg = model.Message;
IsSending = Visibility.Visible;
}
HasError = Visibility.Collapsed;
IsReadyToSend = Visibility.Collapsed;
}
}
protected virtual void OnSendOrderToStoreStatusChanged(OrderModelDto obj)
{
Action <OrderModelDto> handler = SendOrderToStoreStatusChanged;
if (handler != null)
{
handler(obj);
}
}
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"));
}
}
private OrderModelDto GetOrderModel(BuyTicketViewModel model)
{
OrderModelDto result = new OrderModelDto
{
DepartureDate = model.DepartureDate,
Description =
$"{model.DepartureStop} - {model.ArrivalStop}, {model.DepartureDate:g}, в количестве {model.Quantity} шт.",
OperationDate = DateTime.Now
};
return(result);
}
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 OperationResult AddOrderToHistoryUser(OrderModelDto model, string userName)
{
Order order = new Order
{
DepartureDate = model.DepartureDate,
Description = model.Description,
OperationDate = model.OperationDate,
User = _unitOfWork.UsersRepository.GetAll().FirstOrDefault(f => f.Email == userName)
};
_unitOfWork.OrdersRepository.Add(order);
return(_unitOfWork.Save());
}
private static ResponseRd SendOrderToStore(OrderModelDto model, IHubCallerConnectionContext <dynamic> clients, CustomerOrder.Order order)
{
using (var client = new CustomerOrderClient(new BasicHttpBinding(), new EndpointAddress(model.Store.WsAddress + SettingsData.Constants.StoreOrder.WsCustomerOrder)))
{
var iTries = 0;
while (iTries < 3)
{
try
{
var result = client.AddOrder(order);
if (result.IsSuccess && result.Order.orderIdField.IsValidId())
{
clients.Caller.OnSendToStoreEventChange(new ResponseMessage
{
Code = SettingsData.Constants.StoreConst.STORE_RESPONSE_CALL_WS_SUCCESS,
IsSuccess = true,
Message = String.Format("Pedido (ATO ID {0}) enviado de forma exitosa", result.Order.orderIdField)
});
client.Close();
return(result);
}
var resultOrderId = result.IsSuccess ? result.Order.orderIdField : "ND";
SharedLogger.LogError(new Exception(
String.Format("SendOrderToStore: {0} | {1} | {2} | {3} | {4}", result.IsSuccess, result.ErrMsg, result.ResultCode, result.ResultData))
, model.PosOrder, model.Store, model.Phone, model.OrderDetails, model.OrderToStoreId, resultOrderId);
}
catch (Exception ex)
{
SharedLogger.LogError(ex);
clients.Caller.OnSendToStoreEventChange(new ResponseMessage
{
Code = SettingsData.Constants.StoreConst.STORE_RESPONSE_CALL_WS_ERROR,
IsSuccess = false,
Message = String.Format("Intento {0} fallido. Error: {1}", (iTries + 1), ex.Message)
});
}
Thread.Sleep(1000);
iTries++;
}
client.Close();
}
return(null);
}
private void SaveOrderStatus(OrderModelDto model, ResponseRd response)
{
try
{
using (var repository = new StoreRepository())
{
repository.UpdateOrderMode(model.OrderToStoreId, response.Order.orderIdField, response.Order.statusField,
response.Order.modeField, response.Order.modeChargeField, response.Order.promiseTimeField.ToDateTimeSafe());
if (SettingsData.Store.EnableSendEmail)
{
repository.SaveOrderToStoreEmail(model.OrderToStoreId);
}
}
}
catch (Exception ex)
{
SharedLogger.LogError(ex);
}
}
private void SaveRecurrence(OrderModelDto model)
{
try
{
using (var repository = new StoreRepository())
{
var now = DateTime.Now;
repository.SaveRecurrence(new Recurrence
{
ClientId = model.ClientId ?? EntityConstants.NULL_VALUE,
OrderToStoreId = model.OrderToStoreId,
Timestamp = now,
Total = (decimal)model.PosOrder.Total,
TimestampShort = now.ToDateShort()
});
}
}
catch (Exception ex)
{
SharedLogger.LogError(ex);
}
}
private CustomerOrder.Order GenerateCustomerOrder(OrderModelDto model)
{
model.ClientInfo = _repositoryClient.GetClientById(model.ClientId ?? SettingsData.Constants.Entities.NULL_ID_INT);
model.Phone = _repositoryClient.GetPhoneById(model.PhoneId);
var lstItem = new List <Item>();
var dictItem = new Dictionary <long, Item>();
var hasPromo = model.PosOrder.Promos != null && model.PosOrder.Promos.Any();
foreach (var item in model.PosOrder.LstItems)
{
if (hasPromo)
{
if (model.PosOrder.Promos.ContainsKey(item.ItemId))
{
continue;
}
}
var itemToSend = new Item
{
menuItemIdField = item.ItemId.ToString(CultureInfo.InvariantCulture),
nameField = item.Name,
referenceIdField = item.CheckItemId.ToString(CultureInfo.InvariantCulture),
quantityField = SettingsData.Constants.StoreConst.QUANTITY_ITEM,
priceField = item.Price.ToString(CultureInfo.InvariantCulture),
levelField = item.Level.ToString(CultureInfo.InvariantCulture),
modCodeIdField = item.ModCode.ToString(CultureInfo.InvariantCulture),
modGroupIdField = item.Level > 0 ? item.Origin.ToString(CultureInfo.InvariantCulture) : null
};
dictItem[item.CheckItemId] = itemToSend;
if (item.Parent == null)
{
lstItem.Add(itemToSend);
continue;
}
var itemParent = dictItem[item.Parent.CheckItemId];
if (itemParent.subItemsField == null)
{
itemParent.subItemsField = new List <Item> {
itemToSend
};
}
else
{
itemParent.subItemsField.Add(itemToSend);
}
}
var order = new CustomerOrder.Order
{
customerField = new List <OrderCustomer>
{
new OrderCustomer
{
firstNameField = model.ClientInfo.FirstName.SubstringMax(27),
lastNameField = model.ClientInfo.LastName.SubstringMax(27),
addressLine1Field = (model.AddressInfo.MainAddress + (String.IsNullOrWhiteSpace(model.AddressInfo.ExtIntNumber) ?
String.Empty :
String.Format("{0} ", model.AddressInfo.ExtIntNumber))).SubstringMax(44),
addressLine2Field = model.AddressInfo.RegionC.Value,
cityField = model.AddressInfo.RegionB.Value,
stateField = model.AddressInfo.RegionA.Value,
zipCodeField = model.AddressInfo.ZipCode.Value,
emailAddressField = model.ClientInfo.Email,
phoneNumberField = model.Phone,
notesField = model.Message,
addressNotesField = model.AddressInfo.Reference
}
},
referenceIdField = model.OrderToStoreId.ToString(CultureInfo.InvariantCulture),
modeField = model.OrderDetails.PosOrderMode,//SettingsData.Constants.StoreConst.SENDING_MODE_DELIVERY,
//statusField = "InDelay",
itemsField = new List <OrderItems>
{
new OrderItems
{
itemField = lstItem,
}
}
};
if (hasPromo)
{
order.promosField = model.PosOrder.Promos.Values.Select(e =>
{
var j = -1;
return(new OrderPromosPromo
{
promoTypeIdField = e.PromoTypeId.ToString(CultureInfo.InvariantCulture),
itemSelectionsField = e.LstEntries.Select(i =>
{
Item item;
if (dictItem.TryGetValue(i, out item))
{
item.priceField = null;
}
j++;
return new ItemSelection
{
groupIdField = j.ToString(CultureInfo.InvariantCulture),
itemReferenceIdField = i.ToString(CultureInfo.InvariantCulture)
};
}).ToList()
});
}).ToList();
}
if (model.OrderDetails.PosOrderStatus == SettingsData.Constants.StoreConst.MODE_DELIVERY_FUTURE)
{
order.statusField = SettingsData.Constants.TrackConst.IN_DELAY;
order.promiseTimeField = model.OrderDetails.PromiseTime.ToString("o");
}
order.orderNotesField = String.Empty;
if (String.IsNullOrWhiteSpace(model.OrderDetails.ExtraNotes) == false)
{
order.orderNotesField = model.OrderDetails.ExtraNotes;
}
order.orderNotesField = String.Format("{0} | Método de pago: {1} |", order.orderNotesField, model.OrderDetails.Payment.Name);
return(order);
}
private void SendOrderToStoreEvent(OrderModelDto model, IHubCallerConnectionContext <dynamic> clients)
{
try
{
if (StoreIsAlive(model) == false)
{
clients.Caller.OnSendToStoreEventChange(new ResponseMessage
{
Code = SettingsData.Constants.StoreConst.STORE_RESPONSE_PING_ERROR,
IsSuccess = false,
Message = String.Format("La sucursal se encuentra fuera de línea, intente de nuevo por favor o reporte a su supervisor")
});
return;
}
clients.Caller.OnSendToStoreEventChange(new ResponseMessage
{
Code = SettingsData.Constants.StoreConst.STORE_RESPONSE_PING_OK,
IsSuccess = true,
Message = String.Format("La sucursal está en línea, se continua con el envío del pedido")
});
var order = GenerateCustomerOrder(model);
var response = SendOrderToStore(model, clients, order);
if (response == null)
{
clients.Caller.OnSendToStoreEventChange(new ResponseMessage
{
Code = SettingsData.Constants.StoreConst.STORE_RESPONSE_FAILURE,
IsSuccess = true,
Message = String.Format("Después de varios intentos no fue posible enviar el pedido a la sucursal. Por favor intente de nuevo o reporte a su supervisor")
});
return;
}
clients.Caller.OnSendToStoreEventChange(new ResponseMessage
{
Code = SettingsData.Constants.StoreConst.STORE_RESPONSE_ORDER_OK,
IsSuccess = true,
Message = String.Format("El pedido se ha enviado a la sucursal de forma exitosa.{0}# del pedido en la sucursal: {1}" +
"{0}Fecha y tiempo estimado de llegada {2:F}",
Environment.NewLine, response.Order.orderIdField, response.Order.promiseTimeField.ToDateTimeSafe())
});
SaveRecurrence(model);
SaveOrderStatus(model, response);
}
catch (Exception ex)
{
clients.Caller.OnSendToStoreEventChange(new ResponseMessage
{
Code = SettingsData.Constants.StoreConst.STORE_RESPONSE_ORDER_ERROR,
IsSuccess = false,
Message = String.Format("Error al procesar el pedido: {0}", ex.Message)
});
}
}
private void OnSendOrderToStoreOk(IStale <ResponseMessageData <OrderModelDto> > obj, OrderModelDto modelDto)
{
if (obj.IsStale)
{
OnSendOrderToStoreError(Resources.Network.ResNetwork.ERROR_NETWORK_DOWN, modelDto);
return;
}
if (obj.Data.IsSuccess == false)
{
OnSendOrderToStoreError(obj.Data.Message, modelDto);
return;
}
modelDto = obj.Data.Data;
modelDto.HasError = false;
modelDto.Message = String.Format("Enviando a la sucursal: {0}.\nDirección: {1}\nTeléfono(s): {2}",
modelDto.Store.Value, modelDto.Store.MainAddress, string.Join(", ", modelDto.Store.LstPhones));
OnSendOrderToStoreStatusChanged(modelDto);
}
private void OnSendOrderToStoreError(String sMsgErr, OrderModelDto modelDto)
{
modelDto.HasError = true;
modelDto.Message = sMsgErr;
OnSendOrderToStoreStatusChanged(modelDto);
}
private void OnSendOrderToStoreError(Exception ex, OrderModelDto modelDto)
{
OnSendOrderToStoreError(ex.Message, modelDto);
}
