public RegisterStoreResponse Register(RegisterStoreRequest request)
{
RegisterStoreResponse registerStoreResponse = new RegisterStoreResponse();
registerStoreResponse.Message = "Store not registered successfully.";
if (String.IsNullOrEmpty(request.UserInfo.Username) || String.IsNullOrEmpty(request.UserInfo.Password) ||
String.IsNullOrEmpty(request.UserInfo.Email))
{
registerStoreResponse.Message = "Please pass all mandatory fields.";
return(registerStoreResponse);
}
if (new Helper().IsEmailExist(request.UserInfo.Email) || new Helper().IsUserNameExist(request.UserInfo.Username))
{
registerStoreResponse.Message = "Username of Email already exist.";
return(registerStoreResponse);
}
UserEL userEL = new UserEL();
userEL = MapperUtility.MapTo(request.UserInfo, userEL);
if (userHelper.RegisterUser(userEL))
{
registerStoreResponse.Message = "Registration successfully completed.";
registerStoreResponse.IsLoggedIn = registerStoreResponse.IsSuccess = true;
return(registerStoreResponse);
}
else
{
registerStoreResponse.Message = "Some error occured.";
return(registerStoreResponse);
}
}
public async Task <SubscriptionValidationResponse> Run(EventGridEvent[] eventGridEvents)
{
foreach (EventGridEvent eventGridEvent in eventGridEvents)
{
//JObject dataObject = eventGridEvent.Data as JObject;
var test = eventGridEvent.EventType.ToLower() == EventTypeEnumFactory.SubscriptionValidationEvent.ToLower();
// Deserialize the event data into the appropriate type based on event type
if (eventGridEvent.EventType.ToLower() == EventTypeEnumFactory.SubscriptionValidationEvent.ToLower())
{
var json = JsonConvert.SerializeObject(eventGridEvent.Data);
var obj = JsonConvert.DeserializeObject <SubscriptionValidationEventData>(json);
var responseData = new SubscriptionValidationResponse
{
ValidationResponse = obj?.ValidationCode
};
return(responseData);
}
await HandleEventAsync(MapperUtility.Map <EventGridEvent, BaseEvent>(eventGridEvent));
}
await Task.CompletedTask;
return(null);
}
public void FromAddress()
{
if (SelectedDeliveryLine != null && SelectedDeliveryLine.FromAddress != null)
{
var fromAddr = new AddressDTO
{
Country = "Ethiopia",
City = "Addis Abeba"
};
fromAddr = MapperUtility <AddressDTO> .GetMap(SelectedDeliveryLine.FromAddress, fromAddr) as AddressDTO;
if (fromAddr != null)
{
fromAddr.Id = 0;
var addr = new AddressEntry(fromAddr);
addr.ShowDialog();
var dialogueResult = addr.DialogResult;
if (dialogueResult != null && (bool)dialogueResult)
{
SelectedDeliveryLine.FromAddress = fromAddr;
FromAdressDetail = new ObservableCollection <AddressDTO> {
fromAddr
};
}
}
}
}
public void ToAddress()
{
if (SelectedDeliveryLine != null)
{
var toAddr = new AddressDTO
{
Country = "Ethiopia",
City = "Addis Abeba"
};
if (SelectedDeliveryLine.ToAddress != null)
{
toAddr = MapperUtility <AddressDTO> .GetMap(SelectedDeliveryLine.ToAddress, toAddr) as AddressDTO;
}
if (toAddr != null)
{
var addr = new AddressEntry(toAddr);
addr.ShowDialog();
var dialogueResult = addr.DialogResult;
if (dialogueResult != null && (bool)dialogueResult)
{
SelectedDeliveryLine.ToAddress = toAddr;
ToAdressDetail = new ObservableCollection <AddressDTO> {
toAddr
};
}
}
}
}
public AddOrderRecieptResponse AddOrderReciept(AddOrderRecieptRequest request)
{
AddOrderRecieptResponse addOrderRecieptResponse = new AddOrderRecieptResponse();
addOrderRecieptResponse.Message = "Reciept order not added successfully.";
if (String.IsNullOrEmpty(request.AuthToken))
{
addOrderRecieptResponse.Message = "Please pass all mandatory fields.";
return(addOrderRecieptResponse);
}
AuthenticationToken authToken = new Helper().GetAuthenticationToken(request.AuthToken);
if (authToken == null)
{
addOrderRecieptResponse.Message = "Unauthorizes user.";
return(addOrderRecieptResponse);
}
if (request.ReceiverStoreID == 0 || request.RecieptID == 0)
{
addOrderRecieptResponse.Message = "Please pass all values.";
return(addOrderRecieptResponse);
}
ReceiptOrderEL recieptOrderEL = new ReceiptOrderEL();
request.SenderStoreID = Convert.ToInt32(authToken.FkUserID);
recieptOrderEL = MapperUtility.MapTo(request, recieptOrderEL);
if (orderReceiptHelper.IsOrderRecieptAvailable(recieptOrderEL))
{
addOrderRecieptResponse.Message = "This reciept already sent to this store.";
return(addOrderRecieptResponse);
}
if (orderReceiptHelper.AddOrderReceipt(recieptOrderEL))
{
addOrderRecieptResponse.Message = "Reciept order added successfully.";
addOrderRecieptResponse.IsSuccess = true;
RecieptEL recEL = new RecieptEL();
recEL.Price = "0.00";
recEL.Status = ((int)ReceiptStatus.ProcessedToVendor).ToString();
recEL.RecieptID = request.RecieptID;
receiptHelper.UpdateOrderReceipt(recEL);
return(addOrderRecieptResponse);
}
else
{
addOrderRecieptResponse.Message = "Some error occured.";
return(addOrderRecieptResponse);
}
}
public GetAllUsersResponse GetAllUsers(string AuthToken)
{
GetAllUsersResponse getAllUsersResponse = new GetAllUsersResponse();
getAllUsersResponse.IsSuccess = false;
getAllUsersResponse.Message = "Error in getting reciepts. Please try again";
if (String.IsNullOrEmpty(AuthToken))
{
getAllUsersResponse.Message = "Please pass all mandatory fields.";
return(getAllUsersResponse);
}
AuthenticationToken authToken = new Helper().GetAuthenticationToken(AuthToken);
if (authToken == null)
{
getAllUsersResponse.Message = "Unauthorizes user.";
return(getAllUsersResponse);
}
List <UserEL> lstUsers = userHelper.GetAllUsers();
List <UserDTO> lstUserDTO = new List <UserDTO>();
if (lstUsers.Count > 0)
{
foreach (UserEL item in lstUsers)
{
UserDTO userDTO = new UserDTO();
userDTO = MapperUtility.MapTo(item, userDTO);
lstUserDTO.Add(userDTO);
}
getAllUsersResponse.userDetails = lstUserDTO;
getAllUsersResponse.IsSuccess = true;
getAllUsersResponse.Message = "Users returned successfully.";
}
else
{
getAllUsersResponse.Message = "No Reciepts found.";
}
return(getAllUsersResponse);
}
public GetProductResponse GetProductsByReciept(string AuthToken, string RecieptID)
{
GetProductResponse getProductResponse = new GetProductResponse();
getProductResponse.IsSuccess = false;
getProductResponse.Message = "Error in getting reciepts. Please try again";
if (String.IsNullOrEmpty(AuthToken))
{
getProductResponse.Message = "Please pass all mandatory fields.";
return(getProductResponse);
}
AuthenticationToken authToken = new Helper().GetAuthenticationToken(AuthToken);
if (authToken == null)
{
getProductResponse.Message = "Unauthorizes user.";
return(getProductResponse);
}
List <ProductEL> lstProduct = productHelper.GetProductsByReciept(Convert.ToInt32(RecieptID));
List <ProductDTO> lstProductDTO = new List <ProductDTO>();
if (lstProduct.Count > 0)
{
foreach (ProductEL item in lstProduct)
{
ProductDTO productDTO = new ProductDTO();
productDTO = MapperUtility.MapTo(item, productDTO);
lstProductDTO.Add(productDTO);
}
getProductResponse.products = lstProductDTO;
getProductResponse.IsSuccess = true;
getProductResponse.Message = "Product returned successfully.";
}
else
{
getProductResponse.Message = "No products found.";
}
return(getProductResponse);
}
public GetRecieptResponse GetOrderedRecieptsForStore(string AuthToken, string UserID)
{
GetRecieptResponse getRecieptResponse = new GetRecieptResponse();
getRecieptResponse.IsSuccess = false;
getRecieptResponse.Message = "Error in getting ordered reciepts. Please try again";
if (String.IsNullOrEmpty(AuthToken))
{
getRecieptResponse.Message = "Please pass all mandatory fields.";
return(getRecieptResponse);
}
AuthenticationToken authToken = new Helper().GetAuthenticationToken(AuthToken);
if (authToken == null)
{
getRecieptResponse.Message = "Unauthorizes user.";
return(getRecieptResponse);
}
List <RecieptEL> lstReciept = orderReceiptHelper.GetOrderedRecieptsForStore(Convert.ToInt32(UserID));
List <RecieptDTO> lstRecieptDTO = new List <RecieptDTO>();
if (lstReciept.Count > 0)
{
foreach (RecieptEL item in lstReciept)
{
RecieptDTO recieptDTO = new RecieptDTO();
recieptDTO = MapperUtility.MapTo(item, recieptDTO);
lstRecieptDTO.Add(recieptDTO);
}
getRecieptResponse.reciepts = lstRecieptDTO;
getRecieptResponse.IsSuccess = true;
getRecieptResponse.Message = "Ordered reciepts returned successfully.";
}
else
{
getRecieptResponse.Message = "No Reciepts found.";
}
return(getRecieptResponse);
}
public bool AddOrderCandidate(OrderCandidateEL orderCandidateEL)
{
bool isOrderCandidateAdded = false;
try
{
OrderCandidate orderCandidate = new OrderCandidate();
orderCandidate = MapperUtility.MapTo(orderCandidateEL, orderCandidate);
using (uow = new UnitOfWork.UnitOfWork())
{
uow.OrderCandidateRepository.Insert(orderCandidate);
uow.Save();
isOrderCandidateAdded = true;
}
}
catch
{
}
return(isOrderCandidateAdded);
}
public AddRecieptResponse AddReciept(AddRecieptRequest request)
{
AddRecieptResponse addRecieptResponse = new AddRecieptResponse();
addRecieptResponse.Message = "Reciept not added successfully.";
if (String.IsNullOrEmpty(request.AuthToken))
{
addRecieptResponse.Message = "Please pass all mandatory fields.";
return(addRecieptResponse);
}
AuthenticationToken authToken = new Helper().GetAuthenticationToken(request.AuthToken);
if (authToken == null)
{
addRecieptResponse.Message = "Unauthorizes user.";
return(addRecieptResponse);
}
if (String.IsNullOrEmpty(request.recieptDTO.Name))
{
addRecieptResponse.Message = "Please pass reciept name.";
return(addRecieptResponse);
}
RecieptEL recieptEL = new RecieptEL();
recieptEL = MapperUtility.MapTo(request.recieptDTO, recieptEL);
if (receiptHelper.AddReceipt(recieptEL))
{
addRecieptResponse.Message = "Reciept added successfully.";
addRecieptResponse.IsSuccess = true;
return(addRecieptResponse);
}
else
{
addRecieptResponse.Message = "Some error occured.";
return(addRecieptResponse);
}
}
public AddProductResponse AddProduct(AddProductRequest request)
{
AddProductResponse addProductResponse = new AddProductResponse();
addProductResponse.Message = "Product not added successfully.";
if (String.IsNullOrEmpty(request.AuthToken))
{
addProductResponse.Message = "Please pass all mandatory fields.";
return(addProductResponse);
}
AuthenticationToken authToken = new Helper().GetAuthenticationToken(request.AuthToken);
if (authToken == null)
{
addProductResponse.Message = "Unauthorizes user.";
return(addProductResponse);
}
if (String.IsNullOrEmpty(request.productInfo.Name) || String.IsNullOrEmpty(request.productInfo.Quantity))
{
addProductResponse.Message = "Please pass all mandatory fields.";
return(addProductResponse);
}
ProductEL productEL = new ProductEL();
productEL = MapperUtility.MapTo(request.productInfo, productEL);
if (productHelper.AddProduct(productEL))
{
addProductResponse.Message = "Product added successfully.";
addProductResponse.IsSuccess = true;
return(addProductResponse);
}
else
{
addProductResponse.Message = "Some error occured.";
return(addProductResponse);
}
}
public bool AddProduct(ProductEL productEL)
{
bool isProductAdded = false;
try
{
Product product = new Product();
product = MapperUtility.MapTo(productEL, product);
using (uow = new UnitOfWork.UnitOfWork())
{
uow.ProductRepository.Insert(product);
uow.Save();
isProductAdded = true;
}
}
catch
{
isProductAdded = false;
}
return(isProductAdded);
}
public bool EditReceipt(RecieptEL recieptEL)
{
bool isRecieptEdited = false;
try
{
using (uow = new UnitOfWork.UnitOfWork())
{
Reciept reciept = uow.RecieptRepository.GetById(recieptEL.RecieptID);
reciept = MapperUtility.MapTo(recieptEL, reciept);
uow.RecieptRepository.Update(reciept);
uow.Save();
isRecieptEdited = true;
}
}
catch
{
isRecieptEdited = false;
}
return(isRecieptEdited);
}
public bool AddReceipt(RecieptEL recieptEL)
{
bool isRecieptAdded = false;
try
{
Reciept reciept = new Reciept();
reciept = MapperUtility.MapTo(recieptEL, reciept);
using (uow = new UnitOfWork.UnitOfWork())
{
uow.RecieptRepository.Insert(reciept);
uow.Save();
isRecieptAdded = true;
}
}
catch
{
isRecieptAdded = false;
}
return(isRecieptAdded);
}
public bool AddOrderReceipt(ReceiptOrderEL receiptOrderEL)
{
bool isOrderReceiptAdded = false;
try
{
RecieptOrder recieptOrder = new RecieptOrder();
recieptOrder = MapperUtility.MapTo(receiptOrderEL, recieptOrder);
using (uow = new UnitOfWork.UnitOfWork())
{
uow.RecieptOrderRepository.Insert(recieptOrder);
uow.Save();
isOrderReceiptAdded = true;
int orderRecieptID = recieptOrder.RecieptOrderID;
List <Product> lstProduct = uow.ProductRepository.Get().Where(x => x.RecieptID == receiptOrderEL.RecieptID).ToList();
List <OrderCandidate> lstOrderCandidate = new List <OrderCandidate>();
foreach (Product product in lstProduct)
{
OrderCandidate orderCandidate = new OrderCandidate();
orderCandidate.CreatedOn = DateTime.Now.ToString();
orderCandidate.IsAvailable = false;
orderCandidate.Price = "0.00";
orderCandidate.ProductID = product.ProductID;
orderCandidate.StoreID = receiptOrderEL.ReceiverStoreID;
orderCandidate.UpdatedOn = null;
orderCandidate.RecieptOrderID = orderRecieptID;
lstOrderCandidate.Add(orderCandidate);
}
uow.OrderCandidateRepository.InsertBulk(lstOrderCandidate);
uow.Save();
}
}
catch
{
isOrderReceiptAdded = false;
}
return(isOrderReceiptAdded);
}
public bool RegisterUser(UserEL user)
{
bool isUserRegistered = false;
try
{
StoreUser storeUser = new StoreUser();
storeUser = MapperUtility.MapTo(user, storeUser);
using (uow = new UnitOfWork.UnitOfWork())
{
storeUser.Password = EncryptionHelper.Encrypt(storeUser.Password);
uow.StoreUserRepository.Insert(storeUser);
uow.Save();
isUserRegistered = true;
}
}
catch
{
isUserRegistered = false;
}
return(isUserRegistered);
}
public UserEL LoginUser(UserEL userElData)
{
UserEL user = new UserEL();
string PasswordHash = EncryptionHelper.Encrypt(userElData.Password);
using (uow = new UnitOfWork.UnitOfWork())
{
StoreUser storeUserData = uow.StoreUserRepository.Get().Where(u => PasswordHash.Equals(u.Password) &&
userElData.Username.Equals(u.Username)
).FirstOrDefault();
string token;
if (storeUserData != null)
{
AuthenticationToken existingToken = uow.AuthenticationTokenRepository.Get().
Where(auth => auth.FkUserID.Equals(storeUserData.StoreUserID))
.FirstOrDefault();
if (existingToken != null)
{
token = existingToken.Token;
}
else
{
AuthenticationToken authToken = new AuthenticationToken();
authToken.FkUserID = storeUserData.StoreUserID;
token = authToken.Token = Guid.NewGuid().ToString().Replace("-", "");
authToken.CreatedDate = System.DateTime.UtcNow;
uow.AuthenticationTokenRepository.Insert(authToken);
uow.Save();
}
user = MapperUtility.MapTo(storeUserData, user);
user.Token = token;
}
}
return(user);
}
private void SaveDeliveryLine(object obj)
{
try
{
SelectedDeliveryRoute.AssignedToStaffId = SelectedStaff.Id;
if (SelectedVehicle != null)
{
SelectedDeliveryRoute.VehicleId = SelectedVehicle.Id;
}
SelectedDeliveryRoute.FromAddressId = SelectedCompany.AddressId;
SelectedDeliveryRoute.ToAddressId = SelectedDelivery.OrderByClient.AddressId;
_deliveryService.InsertOrUpdateDeliveryRouteChild(SelectedDeliveryRoute);
var delivery = _deliveryService.Find(SelectedDelivery.Id.ToString());
delivery.DeliverDirectly = DeliverDirectly;
delivery.Status = DeliveryStatusTypes.AcceptanceScheduled;
if (SelectedDeliveryRoute.StartedTime != null)
{
delivery.Status = DeliveryStatusTypes.OnAcceptance;
}
if (SelectedDeliveryRoute.StartedTime != null && SelectedDeliveryRoute.EndedTime != null)
{
delivery.Status = DeliveryStatusTypes.Accepted;
}
_deliveryService.InsertOrUpdate(delivery);
//Create Delivery Route for each Line
var delLines = SelectedDelivery.DeliveryLines.Where(
d => d.DeliveryType == DeliveryLineRouteTypes.Delivering).ToList();
foreach (var deliveryLineDTO in delLines)
{
var delRoute =
_deliveryService.GetDeliveryRouteChilds(deliveryLineDTO.Id, false).FirstOrDefault();
if (DeliverDirectly && delRoute == null)
{
delRoute = new DeliveryRouteDTO();
delRoute = (DeliveryRouteDTO)MapperUtility <DeliveryRouteDTO> .GetMap(SelectedDeliveryRoute, delRoute);
delRoute.DeliveryType = DeliveryLineRouteTypes.Delivering;
delRoute.DeliveryLine = null;
delRoute.DeliveryLineId = deliveryLineDTO.Id;
delRoute.FromAddressId = SelectedDelivery.OrderByClient.AddressId;
delRoute.StartedTime = null;
delRoute.EndedTime = null;
delRoute.Id = 0;
_deliveryService.InsertOrUpdateDeliveryRouteChild(delRoute);
}
if (delRoute != null && !DeliverDirectly)
{
delRoute.Enabled = false;
_deliveryService.InsertOrUpdateDeliveryRouteChild(delRoute);
}
}
CloseWindow(obj);
}
catch (Exception exception)
{
MessageBox.Show("Can't save"
+ Environment.NewLine + exception.Message, "Can't save", MessageBoxButton.OK,
MessageBoxImage.Error);
}
}
public async Task <HttpResponseMessage> SendAsync <TEvent, TEventType>(string topicEndpoint, string sasKey, List <TEvent> events) where TEvent : BaseEvent <TEventType>
{
return(await SendAsync(topicEndpoint, sasKey, MapperUtility.Map <List <TEvent>, List <EventGridEvent> >(events)));
}
