public async Task <IHttpActionResult> GetAllStores()
{
try
{
using (DunkeyContext ctx = new DunkeyContext())
{
var stores = ctx.Stores.Where(x => x.IsDeleted == false).Include(x => x.StoreDeliveryHours).Include(x => x.StoreRatings).ToList();
foreach (var store in stores)
{
store.CalculateAverageRating();
}
CustomResponse <IEnumerable <Store> > response = new CustomResponse <IEnumerable <Store> >
{
Message = ResponseMessages.Success,
StatusCode = (int)HttpStatusCode.OK,
Result = stores
};
return(Ok(response));
}
}
catch (Exception ex)
{
return(StatusCode(DunkeyDelivery.Utility.LogError(ex)));
}
}
public IHttpActionResult GetSearchedStores(string search_string, string CategoryType, int ObjectPerPage = 6, int PageNumber = 0)
{
try
{
Shop res = new Shop();
DunkeyContext ctx = new DunkeyContext();
if (string.IsNullOrEmpty(search_string))
{
res.Store = ctx.Stores.Where(x => x.BusinessType == CategoryType).OrderBy(x => x.BusinessName).Skip(ObjectPerPage * PageNumber).Take(ObjectPerPage).ToList();
res.TotalStores = ctx.Stores.Where(x => x.BusinessType == CategoryType).Count();
}
else
{
res.Store = ctx.Stores.Where(x => x.BusinessName.StartsWith(search_string) && x.BusinessType == CategoryType).OrderBy(x => x.BusinessName).Skip(ObjectPerPage * PageNumber).Take(ObjectPerPage).ToList();
}
CustomResponse <Shop> response = new CustomResponse <Shop>
{
Message = "Success",
StatusCode = (int)HttpStatusCode.OK,
Result = res
};
return(Ok(response));
}
catch (Exception ex)
{
return(StatusCode(DunkeyDelivery.Utility.LogError(ex)));
}
}
public static void MakeOrder(this Order order, OrderViewModel model, DunkeyContext ctx)
{
try
{
order.User_ID = model.UserId;
foreach (var cartItem in model.Cart.CartItems)
{
if (order.StoreOrders.Count == 0)
{
order.AddNewStoreOrder(cartItem, ctx);
}
else
{
var existingStoreOrder = order.StoreOrders.FirstOrDefault(x => x.Store_Id == cartItem.StoreId);
if (existingStoreOrder == null)
{
order.AddNewStoreOrder(cartItem, ctx);
}
else
{
existingStoreOrder.AddNewOrderItem(cartItem, ctx);
}
}
}
order.SetOrderDetails(model);
order.CalculateSubTotal();
order.CalculateTotal();
}
catch (Exception ex)
{
DunkeyDelivery.Utility.LogError(ex);
}
}
public async Task <ActionResult> ResetPassword(ResetPasswordViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
using (DunkeyContext ctx = new DunkeyContext())
{
var tokens = ctx.ForgotPasswordTokens.Where(x => x.User_Id == model.UserId && x.IsDeleted == false);
if (tokens.Count() > 0)
{
foreach (var token in tokens)
{
token.IsDeleted = true;
}
ctx.Users.FirstOrDefault(x => x.Id == model.UserId).Password = model.Password;
ctx.SaveChanges();
}
}
return(View("PasswordResetSuccess"));
}
public IHttpActionResult GetRewardPrizes(int UserID)
{
try
{
using (DunkeyContext ctx = new DunkeyContext())
{
RewardViewModel resp = new RewardViewModel();
var RewardMilestone = ctx.RewardMilestones.Include(x => x.RewardPrize).ToList();
//var RewardMilestone1 = ctx.RewardMilestones.Include(x => x.RewardPrize);
resp.Rewards = RewardMilestone;
var CurrentUser = ctx.Users.Where(x => x.Id == UserID).FirstOrDefault();
resp.UserPoints.RewardPoints = CurrentUser.RewardPoints;
CustomResponse <RewardViewModel> response = new CustomResponse <RewardViewModel>
{
Message = "Success",
StatusCode = (int)HttpStatusCode.OK,
Result = resp
};
return(Ok(response));
}
}
catch (Exception ex)
{
return(StatusCode(DunkeyDelivery.Utility.LogError(ex)));
}
}
public async Task <IHttpActionResult> AlcoholHomeScreen(double latitude, double longitude, int?Page = 0, int?Items = 10, string Store_Ids = "")
{
try
{
using (DunkeyContext ctx = new DunkeyContext())
{
AlcoholViewModel model = new AlcoholViewModel();
var Stores = new List <Store>();
string[] StoreIdsString;
int[] StoreIdsInt = new int[0];
var point = DunkeyDelivery.Utility.CreatePoint(latitude, longitude);
if (!string.IsNullOrEmpty(Store_Ids))
{
StoreIdsString = Store_Ids.Split(',');
StoreIdsInt = Array.ConvertAll(StoreIdsString, s => int.Parse(s));
}
if (StoreIdsInt.Length != 0)
{
Stores = ctx.Stores.Include(x => x.Categories).Include(x => x.Products).Include(x => x.StoreTags).Where(x => StoreIdsInt.Contains(x.Id) && x.BusinessType == Utility.Global.Constants.Alcohol && x.IsDeleted == false).OrderBy(x => x.Id).Skip(Page.Value * Items.Value).Take(Items.Value).ToList();
}
else
{
Stores = ctx.Stores.Include(x => x.Categories).Include(x => x.Products).Include(x => x.StoreTags).Where(x => x.Location.Distance(point) < DunkeyDelivery.Global.NearbyStoreRadius && x.BusinessType == Utility.Global.Constants.Alcohol && x.IsDeleted == false).OrderBy(x => x.Id).Skip(Page.Value * Items.Value).Take(Items.Value).ToList();
}
if (Stores.Count > 0)
{
foreach (var store in Stores)
{
if (store.Categories.Any(x => (x.Name.Contains("Wine") || x.Name.Contains("Liquor")) && x.ParentCategoryId == 0))
{
foreach (var cat in store.Categories)
{
store.Categories = store.Categories.Where(x => x.IsDeleted == false && x.Store_Id == store.Id && x.ParentCategoryId == 0).ToList();
foreach (var prod in cat.Products)
{
prod.BusinessName = store.BusinessName;
cat.Products = cat.Products.Where(x => x.IsDeleted == false && x.Category_Id == cat.Id).ToList();
}
}
store.Distance = store.Location.Distance(point).Value;
store.CalculateAverageRating();
model.Stores.Add(store);
}
}
}
return(Ok(new CustomResponse <AlcoholViewModel> {
Message = Global.ResponseMessages.Success, StatusCode = (int)HttpStatusCode.OK, Result = model
}));
}
}
catch (Exception ex)
{
return(StatusCode(DunkeyDelivery.Utility.LogError(ex)));
}
}
public async Task <IHttpActionResult> AddProduct(ProductBindingModel model)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
using (DunkeyContext ctx = new DunkeyContext())
{
var newProductModel = new Product {
Store_Id = model.Store_Id, Category_Id = model.Category_Id, Name = model.Name, Description = model.Description, Price = model.Price, Status = 0
};
ctx.Products.Add(newProductModel);
ctx.SaveChanges();
CustomResponse <Product> response = new CustomResponse <Product> {
Message = "Success", StatusCode = (int)HttpStatusCode.OK, Result = newProductModel
};
return(Ok(response));
}
}
catch (Exception ex)
{
return(StatusCode(DunkeyDelivery.Utility.LogError(ex)));
}
}
public IHttpActionResult GetStoreProducts(short Store_id, int Page = 0, int Items = 10)
{
try
{
CategoryProductViewModel responsee = new CategoryProductViewModel();
using (DunkeyContext ctx = new DunkeyContext())
{
var res = ctx.Products
.Where(x => x.Store_Id == Store_id && x.IsDeleted == false).OrderBy(x => x.Name).Skip(Page * Items).Take(Items).ToList();
var f = Mapper.Map <List <productslist> >(res);
responsee.productslist = f;
responsee.TotalRecords = ctx.Products.Where(x => x.Store_Id == Store_id && x.IsDeleted == false).Count();
CustomResponse <CategoryProductViewModel> response = new CustomResponse <CategoryProductViewModel>
{
Message = "Success",
StatusCode = (int)HttpStatusCode.OK,
Result = responsee
};
return(Ok(response));
}
}
catch (Exception ex)
{
return(StatusCode(DunkeyDelivery.Utility.LogError(ex)));
}
}
public IHttpActionResult GetAlcoholStores(string search_string, string CategoryType, int Store_Id)
{
try
{
CategoryProductViewModel res = new CategoryProductViewModel();
DunkeyContext ctx = new DunkeyContext();
if (string.IsNullOrEmpty(search_string))
{
var productList = ctx.Products.Where(x => x.Store_Id == Store_Id && x.IsDeleted == false).ToList();
res.productslist = Mapper.Map <List <productslist> >(productList);
//res.TotalRecords = ctx.Products.Where(x => x.Store.BusinessType == CategoryType).Count();
}
else
{
var productList = ctx.Products.Where(x => x.Name.Contains(search_string) && x.Store_Id == Store_Id && x.IsDeleted == false).ToList();
res.productslist = Mapper.Map <List <productslist> >(productList);
}
CustomResponse <CategoryProductViewModel> response = new CustomResponse <CategoryProductViewModel>
{
Message = "Success",
StatusCode = (int)HttpStatusCode.OK,
Result = res
};
return(Ok(response));
}
catch (Exception ex)
{
return(StatusCode(DunkeyDelivery.Utility.LogError(ex)));
}
}
public async Task <IHttpActionResult> GetContentByType(int Type)
{
try
{
using (DunkeyContext ctx = new DunkeyContext())
{
var content = ctx.Content.FirstOrDefault(x => x.Type == Type);
if (content != null)
{
return(Ok(new CustomResponse <Content> {
Message = ResponseMessages.Success, StatusCode = (int)HttpStatusCode.OK, Result = content
}));
}
return(Content(HttpStatusCode.OK, new CustomResponse <Error>
{
Message = "Not Found",
StatusCode = (int)HttpStatusCode.NotFound,
Result = new Error {
ErrorMessage = "Record not found."
}
}));
}
}
catch (Exception ex)
{
return(StatusCode(DunkeyDelivery.Utility.LogError(ex)));
}
}
public async Task <IHttpActionResult> GetSubCategoriesByCatId(int CatId)
{
try
{
using (DunkeyContext ctx = new DunkeyContext())
{
var categories = ctx.Categories.Where(x => x.ParentCategoryId == CatId && x.IsDeleted == false).OrderBy(x => x.Name).ToList();
categories.Insert(0, new Category {
Name = "All", Id = CatId
});
CustomResponse <Models.Admin.CategoriesViewModel> response = new CustomResponse <Models.Admin.CategoriesViewModel>
{
Message = ResponseMessages.Success,
StatusCode = (int)HttpStatusCode.OK,
Result = new Models.Admin.CategoriesViewModel {
Categories = categories
}
};
return(Ok(response));
}
}
catch (Exception ex)
{
return(StatusCode(DunkeyDelivery.Utility.LogError(ex)));
}
}
public async Task <IHttpActionResult> DeleteEntity(int Id)
{
try
{
using (DunkeyContext ctx = new DunkeyContext())
{
var Blog = ctx.BlogPosts.FirstOrDefault(x => x.Id == Id);
if (Blog != null)
{
Blog.is_deleted = 1;
ctx.SaveChanges();
return(Ok(new CustomResponse <string> {
Message = ResponseMessages.Success, StatusCode = (int)HttpStatusCode.OK
}));
}
return(Content(HttpStatusCode.OK, new CustomResponse <Error>
{
Message = "Not Found",
StatusCode = (int)HttpStatusCode.NotFound,
Result = new Error {
ErrorMessage = "Record not found."
}
}));
}
}
catch (Exception ex)
{
return(StatusCode(DunkeyDelivery.Utility.LogError(ex)));
}
}
public IHttpActionResult GetPrizes(int?Page = 0, int?Items = 0)
{
try
{
using (DunkeyContext ctx = new DunkeyContext())
{
double TotalPrize = 0;
Rewards resp = new Rewards();
var Rewards = ctx.RewardMilestones.Include(x => x.RewardPrize).ToList(); // bug asi
if (Rewards == null)
{
return(Ok(new CustomResponse <Error> {
Message = Global.ResponseMessages.NotFound, StatusCode = (int)HttpStatusCode.NotFound, Result = new Error {
ErrorMessage = "Reward list not found."
}
}));
}
resp.RewardsList = Rewards;
CustomResponse <Rewards> response = new CustomResponse <Rewards>
{
Message = "Success",
StatusCode = (int)HttpStatusCode.OK,
Result = resp
};
return(Ok(response));
}
}
catch (Exception ex)
{
return(StatusCode(DunkeyDelivery.Utility.LogError(ex)));
}
}
public async Task <IHttpActionResult> GetEntityById(int Id)
{
try
{
using (DunkeyContext ctx = new DunkeyContext())
{
var Blog = ctx.BlogPosts.FirstOrDefault(x => x.Id == Id && x.is_deleted == 0);
if (Blog == null)
{
return(Ok(new CustomResponse <Error> {
Message = ResponseMessages.NotFound, StatusCode = (int)HttpStatusCode.NotFound, Result = new Error {
ErrorMessage = "Record not found"
}
}));
}
return(Ok(new CustomResponse <DAL.BlogPosts> {
Message = ResponseMessages.Success, StatusCode = (int)HttpStatusCode.OK, Result = Blog
}));
}
}
catch (Exception ex)
{
return(StatusCode(DunkeyDelivery.Utility.LogError(ex)));
}
}
public async Task <IHttpActionResult> SearchBlogs(string BlogTitle, string CategoryType, string DateOfPosting)
{
try
{
using (DunkeyContext ctx = new DunkeyContext())
{
string conditions = string.Empty;
if (!String.IsNullOrEmpty(BlogTitle))
{
conditions += "AND BlogPosts.Title LIKE '%" + BlogTitle + "%'";
}
if (!String.IsNullOrEmpty(CategoryType))
{
conditions += "AND CategoryType='" + CategoryType + "'";
}
if (DateOfPosting != null)
{
conditions += "OR DateOfPosting='" + Convert.ToDateTime(DateOfPosting) + "'";
}
#region query
var query = @"select
BlogPosts.Id,
BlogPosts.Title,
BlogPosts.CategoryType,
BlogPosts.DateOfPosting,
BlogPosts.Description,
BlogPosts.ImageUrl,
BlogPosts.is_popular,
BlogPosts.Title,
BlogPosts.Admin_ID,
BlogPosts.is_deleted,
Admins.Email
from BlogPosts
LEFT JOIN Admins
ON Admins.Id=BlogPosts.Admin_ID
Where BlogPosts.is_deleted=0 " + conditions + "";
#endregion
var Blogs = ctx.Database.SqlQuery <SearchBlogViewModel>(query).ToList();
return(Ok(new CustomResponse <SearchBlogListViewModel> {
Message = ResponseMessages.Success, StatusCode = (int)HttpStatusCode.OK, Result = new SearchBlogListViewModel {
BlogList = Blogs
}
}));
}
}
catch (Exception ex)
{
return(StatusCode(DunkeyDelivery.Utility.LogError(ex)));
}
}
public IHttpActionResult GetStoreById(short Id)
{
try
{
DunkeyContext ctx = new DunkeyContext();
var res = ctx.Stores.Where(x => x.Id == Id && x.IsDeleted == false).Include("StoreDeliveryHours").Include(x => x.StoreRatings).First();
if (res != null)
{
res.CalculateAverageRating();
}
var businessTypeTax = ctx.BusinessTypeTax.FirstOrDefault(x => x.BusinessType.Equals(res.BusinessType));
if (businessTypeTax != null)
{
res.BusinessTypeTax = businessTypeTax.Tax;
}
CustomResponse <Store> response = new CustomResponse <Store>
{
Message = "Success",
StatusCode = (int)HttpStatusCode.OK,
Result = res
};
return(Ok(response));
}
catch (Exception ex)
{
return(StatusCode(DunkeyDelivery.Utility.LogError(ex)));
}
}
public IHttpActionResult SearchByType(string Type, int items, int Page)
{
try
{
using (DunkeyContext ctx = new DunkeyContext())
{
var res = ctx.Stores.Include("StoreTags").Include(x => x.StoreRatings).Where(x => x.BusinessType == Type && x.IsDeleted == false).OrderBy(x => x.Id).Skip(items * Page).Take(items).ToList();
foreach (var storeRating in res)
{
storeRating.CalculateAverageRating();
}
res = res.OrderByDescending(x => x.AverageRating).ToList();
//var businessTypeTax = ctx.BusinessTypeTax.FirstOrDefault(x => x.BusinessType.Equals(res.BusinessType));
//if (businessTypeTax != null)
// res.BusinessTypeTax = businessTypeTax.Tax;
var TotalStores = ctx.Stores.Where(x => x.BusinessType == Type).Count();
CustomResponse <Shop> response = new CustomResponse <Shop>
{
Message = "Success",
StatusCode = (int)HttpStatusCode.OK,
Result = new Shop {
Store = res, TotalStores = TotalStores
}
};
return(Ok(response));
}
}
catch (Exception ex)
{
return(StatusCode(DunkeyDelivery.Utility.LogError(ex)));
}
}
public IHttpActionResult GetMedicationNames(short Store_Id, string search_string)
{
try
{
using (DunkeyContext ctx = new DunkeyContext())
{
var response = ctx.Products.Where(x => x.Name.Contains(search_string) && x.Store_Id == Store_Id && x.IsDeleted == false).ToList();
var f = Mapper.Map <List <MedicationNames> >(response);
Medications responseModel = new Medications {
medications = f
};
CustomResponse <Medications> res = new CustomResponse <Medications>
{
Message = "Success",
StatusCode = (int)HttpStatusCode.OK,
Result = responseModel
};
return(Ok(res));
}
}
catch (Exception ex)
{
return(StatusCode(DunkeyDelivery.Utility.LogError(ex)));
}
}
public async Task <IHttpActionResult> Register(DriverBindingModel model)
{
model.Role = 0;
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
using (DunkeyContext ctx = new DunkeyContext())
{
if (ctx.Drivers.Any(x => x.Email == model.Email))
{
return(Content(HttpStatusCode.OK, new CustomResponse <Error>
{
Message = "Conflict",
StatusCode = (int)HttpStatusCode.Conflict,
Result = new Error {
ErrorMessage = "Driver with email already exists"
}
}));
//return BadRequest("User with the same email already exists.");
//return Request.CreateResponse(HttpStatusCode.OK, new Error { ErrorCode = "400 Conflict", Message = "User with email already exist"});
}
else
{
Driver driverModel = new Driver
{
FullName = model.FullName,
Email = model.Email,
Phone = model.Phone,
City = model.City,
VehicleType = model.VehicleType,
HearFrom = model.HearFrom
};
ctx.Drivers.Add(driverModel);
ctx.SaveChanges();
using (DriverViewModel driverViewModel = new DriverViewModel(driverModel))
{
//driverViewModel.Token = await Utility.GenerateToken(driverModel.Email, driverModel.Password, Request);
CustomResponse <DriverViewModel> response = new CustomResponse <DriverViewModel> {
Message = "Success", StatusCode = (int)HttpStatusCode.OK, Result = driverViewModel
};
return(Ok(response));
//return Request.CreateResponse(HttpStatusCode.OK, response);
}
}
}
}
catch (Exception ex)
{
return(StatusCode(DunkeyDelivery.Utility.LogError(ex)));
}
}
public async Task <IHttpActionResult> GetContentEntities(Content BindingModel)
{
try
{
using (DunkeyContext ctx = new DunkeyContext())
{
var content = ctx.Content.FirstOrDefault(x => x.Type == BindingModel.Type);
if (BindingModel.Id == 0)
{
return(Ok(new CustomResponse <Content> {
Message = ResponseMessages.Success, StatusCode = (int)HttpStatusCode.OK, Result = content
}));
}
if (content != null)
{
content.VideoUrl = BindingModel.VideoUrl;
content.Description = BindingModel.Description;
content.Heading = BindingModel.Heading;
content.ImageUrl = BindingModel.ImageUrl;
content.Title = BindingModel.Title;
ctx.SaveChanges();
return(Ok(new CustomResponse <Content> {
Message = ResponseMessages.Success, StatusCode = (int)HttpStatusCode.OK, Result = content
}));
}
else
{
Content NewContent = new Content
{
Description = BindingModel.Description,
VideoUrl = BindingModel.VideoUrl,
Type = (int)DunkeyDelivery.Content.Types.AboutUs,
Heading = BindingModel.Heading,
Title = BindingModel.Title,
ImageUrl = BindingModel.ImageUrl
};
ctx.Content.Add(NewContent);
ctx.SaveChanges();
return(Ok(new CustomResponse <Content> {
Message = ResponseMessages.Success, StatusCode = (int)HttpStatusCode.OK, Result = NewContent
}));
}
return(Content(HttpStatusCode.OK, new CustomResponse <Error>
{
Message = "Not Found",
StatusCode = (int)HttpStatusCode.NotFound,
Result = new Error {
ErrorMessage = "Record not found."
}
}));
}
}
catch (Exception ex)
{
return(StatusCode(DunkeyDelivery.Utility.LogError(ex)));
}
}
public IHttpActionResult GetBlogPosts(int Page = 0, int Items = 6)
{
try
{
using (DunkeyContext ctx = new DunkeyContext())
{
BlogPostListViewModel model = new BlogPostListViewModel();
model.BlogPosts = ctx.BlogPosts.Include(c => c.Admin).OrderBy(x => x.Title).Skip(Page * Items).Take(Items).ToList();
foreach (var post in model.BlogPosts)
{
post.TotalComments = ctx.BlogComments.Count(x => x.Post_Id == post.Id);
}
// popular categories
var query = "select CategoryType, COUNT(CategoryType)AS TotalCount from BlogPosts GROUP BY BlogPosts.CategoryType ORDER BY TotalCount DESC OFFSET 0 ROWS FETCH NEXT 3 ROWS ONLY";
var popularCategories = ctx.Database.SqlQuery <popularCategories>(query).ToList();
model.popularCategories = popularCategories;
CustomResponse <BlogPostListViewModel> response = new CustomResponse <BlogPostListViewModel>
{
Message = DunkeyDelivery.Global.SuccessMessage,
StatusCode = (int)HttpStatusCode.OK,
Result = model
};
return(Ok(response));
//return Ok(new CustomResponse<BlogPostListViewModel>
//{
// Message = "Success",
// StatusCode = (int)HttpStatusCode.OK,
// Result = new BlogPostListViewModel
// {
// BlogPosts = ctx.BlogPosts.Include(c => c.User).Include(c => c.BlogComments).Select(x => new BlogPosts
// {
// TotalComments = x.BlogComments.Count,
// Id = x.Id,
// Title= x.Title,
// is_popular=x.is_popular,
// ImageUrl= x.ImageUrl,
// User= x.User,
// Description=x.Description,
// DateOfPosting= x.DateOfPosting,
// CategoryType= x.CategoryType
// }).ToList()
// }
//});
}
}
catch (Exception ex)
{
return(StatusCode(DunkeyDelivery.Utility.LogError(ex)));
}
}
public async Task <IHttpActionResult> Register(RideBindingModel model)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
using (DunkeyContext ctx = new DunkeyContext())
{
if (ctx.Rider.Any(x => x.Email == model.Email))
{
return(Content(HttpStatusCode.OK, new CustomResponse <Error>
{
Message = "Conflict",
StatusCode = (int)HttpStatusCode.Conflict,
Result = new Error {
ErrorMessage = "Rider with email already exists"
}
}));
}
else
{
Rider rideModel = new Rider()
{
FullName = model.FullName,
BusinessName = model.BusinessName,
Email = model.Email,
BusinessType = model.BusinessType,
Status = (int)Global.StatusCode.NotVerified,
Phone = model.Phone,
ZipCode = model.ZipCode
};
ctx.Rider.Add(rideModel);
ctx.SaveChanges();
using (RideViewModel rideViewModel = new RideViewModel(rideModel))
{
//userViewModel.Token = await Utility.GenerateToken(userModel.Email, userModel.Password, Request);
CustomResponse <RideViewModel> response = new CustomResponse <RideViewModel> {
Message = "Success", StatusCode = (int)HttpStatusCode.OK, Result = rideViewModel
};
return(Ok(response));
//return Request.CreateResponse(HttpStatusCode.OK, response);
}
}
}
}
catch (Exception ex)
{
return(StatusCode(DunkeyDelivery.Utility.LogError(ex)));
}
}
public IHttpActionResult GetRedeemedPrize(int UserID)
{
try
{
using (DunkeyContext ctx = new DunkeyContext())
{
double TotalPrize = 0;
UserReward resp = new UserReward();
var UserRewards = ctx.UserRewards.Include("RewardMilestones").Include("User").Where(x => x.User_Id == UserID && x.is_deleted == 0).ToList();
if (UserRewards == null)
{
return(Ok(new CustomResponse <Error> {
Message = Global.ResponseMessages.BadRequest, StatusCode = (int)HttpStatusCode.BadRequest, Result = new Error {
ErrorMessage = "No redeemed prize found."
}
}));
}
foreach (var Reward in UserRewards)
{
if (Reward.RewardMilestones.RewardPrize_Id.HasValue)
{
return(Ok(new CustomResponse <Error> {
Message = Global.ResponseMessages.BadRequest, StatusCode = (int)HttpStatusCode.BadRequest, Result = new Error {
ErrorMessage = "Prize cannot be redeemed."
}
}));
}
else
{
TotalPrize = +Reward.RewardMilestones.AmountAward;
}
}
resp.RewardAmount = TotalPrize;
CustomResponse <UserReward> response = new CustomResponse <UserReward>
{
Message = "Success",
StatusCode = (int)HttpStatusCode.OK,
Result = resp
};
return(Ok(response));
//CustomResponse<RewardViewModel> response = new CustomResponse<RewardViewModel>
//{
// Message = "Success",
// StatusCode = (int)HttpStatusCode.OK,
// Result = resp
//};
//return Ok(response);
}
}
catch (Exception ex)
{
return(StatusCode(DunkeyDelivery.Utility.LogError(ex)));
}
}
public static void SetOrderDetails(this Order order, OrderViewModel model)
{
try
{
order.OrderNo = Guid.NewGuid().ToString("N").ToUpper();
order.OrderDateTime = DateTime.Now;
order.Status = (int)OrderStatuses.Initiated;
order.DeliveryTime_From = model.DeliveryDateTime_From;
order.DeliveryTime_To = model.DeliveryDateTime_To;
order.PaymentMethod = model.PaymentMethodType;
order.User_ID = model.UserId;
if (string.IsNullOrEmpty(order.DeliveryDetails_Address) && string.IsNullOrEmpty(order.DeliveryDetails_Phone))
{
var UserAddress = new UserAddress();
using (DunkeyContext ctx = new DunkeyContext())
{
//Set Delivery Details
UserAddress = ctx.UserAddresses.Include(x => x.User).FirstOrDefault(x => x.User_ID == order.User_ID && x.IsPrimary == true && x.IsDeleted == false);
if (UserAddress == null)
{
UserAddress = ctx.UserAddresses.Include(x => x.User).Where(x => x.User_ID == order.User_ID && x.IsDeleted == false).OrderByDescending(x => x.Id).FirstOrDefault();
}
}
order.DeliveryDetails_FirstName = UserAddress.User.FirstName;
order.DeliveryDetails_LastName = UserAddress.User.LastName;
order.DeliveryDetails_Phone = UserAddress.Telephone;
order.DeliveryDetails_ZipCode = UserAddress.PostalCode;
order.DeliveryDetails_Email = UserAddress.User.Email;
order.DeliveryDetails_City = UserAddress.City;
order.DeliveryDetails_Address = UserAddress.FullAddress;
order.DeliveryDetails_AddtionalNote = model.DeliveryDetails.AdditionalNote;
}
else
{
order.DeliveryDetails_FirstName = model.DeliveryDetails.FirstName;
order.DeliveryDetails_LastName = model.DeliveryDetails.LastName;
order.DeliveryDetails_Phone = model.DeliveryDetails.Phone;
order.DeliveryDetails_ZipCode = model.DeliveryDetails.ZipCode;
order.DeliveryDetails_Email = model.DeliveryDetails.Email;
order.DeliveryDetails_City = model.DeliveryDetails.City;
order.DeliveryDetails_Address = model.DeliveryDetails.Address;
order.DeliveryDetails_AddtionalNote = model.DeliveryDetails.AdditionalNote;
}
order.TipAmount = model.TipAmount;
}
catch (Exception ex)
{
DunkeyDelivery.Utility.LogError(ex);
}
}
public async Task <IHttpActionResult> SubmitPharmacyRequest(PharmacyRequestBindingModel model)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
else if (model.Product_Ids.Count == 0)
{
return(Ok(new CustomResponse <Error> {
Message = Utility.Global.ResponseMessages.BadRequest, StatusCode = (int)HttpStatusCode.Forbidden, Result = new Error {
ErrorMessage = "Please add medicines"
}
}));
}
using (DunkeyContext ctx = new DunkeyContext())
{
PharmacyRequest pharmModel = new PharmacyRequest
{
Delivery_Address = model.Delivery_Address,
Delivery_City = model.Delivery_City,
Delivery_Phone = model.Delivery_Phone,
Delivery_State = model.Delivery_State,
Delivery_Zip = model.Delivery_Zip,
Doctor_FirstName = model.Doctor_FirstName,
Doctor_LastName = model.Doctor_LastName,
Doctor_Phone = model.Doctor_Phone,
Gender = model.Gender,
Patient_DOB = DateTime.ParseExact(model.Patient_DOB, "dd/MM/yyyy hh:mm:ss tt", System.Globalization.CultureInfo.InvariantCulture),
Patient_FirstName = model.Patient_FirstName,
Patient_LastName = model.Patient_LastName,
CreatedDate = DateTime.Now
};
foreach (var productId in model.Product_Ids)
{
pharmModel.PharmacyRequest_Products.Add(new PharmacyRequest_Products {
Product_Id = productId.Value
});
}
ctx.PharmacyRequest.Add(pharmModel);
ctx.SaveChanges();
return(Ok(new CustomResponse <PharmacyRequest> {
Message = Utility.Global.ResponseMessages.Success, StatusCode = (int)HttpStatusCode.OK
}));
}
}
catch (Exception ex)
{
return(StatusCode(DunkeyDelivery.Utility.LogError(ex)));
}
}
public IHttpActionResult SearchProductByName(string search_string, int Category_id = 10)
{
try
{
Stores Utility = new Stores();
List <Product> products = new List <Product>();
var Type = Utility.Categories_enum(Category_id);
using (DunkeyContext ctx = new DunkeyContext())
{
var query = "SELECT Products.* FROM Stores INNER JOIN Products ON Products.Store_id = Stores.Id";
if (Type == "All")
{
if (string.IsNullOrEmpty(search_string))
{
}
else
{
query += " WHERE Products.Name Like '%" + search_string.Trim() + "%' ";
}
}
else
{
query += " WHERE Stores.BusinessType='" + Type + "'";
if (string.IsNullOrEmpty(search_string))
{
}
else
{
query += " AND Products.Name Like '%" + search_string.Trim() + "%'";
}
}
products = ctx.Database.SqlQuery <Product>(query).ToList();
//var res = ctx.Products
// .Where(x => x.Name.StartsWith(search_string)).ToList();
//ClientProductViewModel model = new ClientProductViewModel();
//model= Mapper.Map<ClientProductViewModel>(res);
CustomResponse <List <Product> > response = new CustomResponse <List <Product> >
//CustomResponse<IEnumerable<Product>> response = new CustomResponse<IEnumerable<Product>>
{
Message = "Success",
StatusCode = (int)HttpStatusCode.OK,
Result = products
};
return(Ok(response));
}
}
catch (Exception ex)
{
return(StatusCode(DunkeyDelivery.Utility.LogError(ex)));
}
}
public async Task <IHttpActionResult> GetEntityById(int EntityType, int Id)
{
try
{
using (DunkeyContext ctx = new DunkeyContext())
{
switch (EntityType)
{
case (int)DunkeyEntityTypes.Product:
return(Ok(new CustomResponse <Product> {
Message = ResponseMessages.Success, StatusCode = (int)HttpStatusCode.OK, Result = ctx.Products.FirstOrDefault(x => x.Id == Id && x.IsDeleted == false)
}));
case (int)DunkeyEntityTypes.Category:
return(Ok(new CustomResponse <Category> {
Message = ResponseMessages.Success, StatusCode = (int)HttpStatusCode.OK, Result = ctx.Categories.FirstOrDefault(x => x.Id == Id && x.IsDeleted == false)
}));
case (int)DunkeyEntityTypes.Store:
return(Ok(new CustomResponse <Store> {
Message = ResponseMessages.Success, StatusCode = (int)HttpStatusCode.OK, Result = ctx.Stores.Include(x => x.StoreDeliveryHours).FirstOrDefault(x => x.Id == Id && x.IsDeleted == false)
}));
case (int)DunkeyEntityTypes.Package:
return(Ok(new CustomResponse <Package> {
Message = ResponseMessages.Success, StatusCode = (int)HttpStatusCode.OK, Result = ctx.Packages.FirstOrDefault(x => x.Id == Id && x.IsDeleted == false)
}));
case (int)DunkeyEntityTypes.Admin:
return(Ok(new CustomResponse <DAL.Admin> {
Message = ResponseMessages.Success, StatusCode = (int)HttpStatusCode.OK, Result = ctx.Admins.FirstOrDefault(x => x.Id == Id)
}));
case (int)DunkeyEntityTypes.Offer:
return(Ok(new CustomResponse <DAL.Offer> {
Message = ResponseMessages.Success, StatusCode = (int)HttpStatusCode.OK, Result = ctx.Offers.FirstOrDefault(x => x.Id == Id && x.IsDeleted == false)
}));
default:
return(Ok(new CustomResponse <Error> {
Message = ResponseMessages.BadRequest, StatusCode = (int)HttpStatusCode.BadRequest, Result = new Error {
ErrorMessage = "Invalid entity type"
}
}));
}
}
}
catch (Exception ex)
{
return(StatusCode(DunkeyDelivery.Utility.LogError(ex)));
}
}
public IHttpActionResult GetStoreByIdMobile(short Id, double?latitude = 0, double?longitude = 0)
{
try
{
DunkeyContext ctx = new DunkeyContext();
var res = new Store();
var Distance = 0.0;
if (latitude != 0 && longitude != 0)
{
var point = DunkeyDelivery.Utility.CreatePoint(latitude.Value, longitude.Value);
res = ctx.Stores.Include(z => z.StoreRatings.Select(y => y.User)).Include(z => z.StoreTags).Where(x => x.Id == Id && x.IsDeleted == false).Include("StoreDeliveryHours").First();
res.Distance = res.Location.Distance(point).Value;
}
else
{
res = ctx.Stores.Include(z => z.StoreRatings.Select(y => y.User)).Include(z => z.StoreTags).Where(x => x.Id == Id && x.IsDeleted == false).Include("StoreDeliveryHours").First();
}
var businessTypeTax = ctx.BusinessTypeTax.FirstOrDefault(x => x.BusinessType.Equals(res.BusinessType));
if (businessTypeTax != null)
{
res.BusinessTypeTax = businessTypeTax.Tax;
}
if (res != null)
{
res.SetAverageRating();
res.CalculateAllTypesAverageRating();
foreach (var item in res.StoreRatings)
{
var query = "select User_Id, Count(Store_Id) as Count from storeratings group by User_Id";
var resp = ctx.Database.SqlQuery <UserRatingCount>(query).ToList();
item.User.TotalReviews = resp.FirstOrDefault(x => x.User_Id == item.User.Id).Count;
item.User.TotalOrders = ctx.Orders.Count(x => x.User_ID == item.User.Id);
}
}
CustomResponse <Store> response = new CustomResponse <Store>
{
Message = "Success",
StatusCode = (int)HttpStatusCode.OK,
Result = res
};
return(Ok(response));
}
catch (Exception ex)
{
return(StatusCode(DunkeyDelivery.Utility.LogError(ex)));
}
}
public async Task <IHttpActionResult> GetProductsByCategoryId(int CatId, int UserId, int PageSize, int PageNo, string filterTypes = "", bool IsAll = false)
{
try
{
using (DunkeyContext ctx = new DunkeyContext())
{
var userFavourites = ctx.Favourites.Where(x => x.User_ID == UserId && x.IsDeleted == false).ToList();
List <Product> products;
int TotalCount;
if (IsAll)
{
var CatIds = ctx.Categories.Where(x => x.Id == CatId || x.ParentCategoryId == CatId && x.IsDeleted == false).Select(x => x.Id).ToList();
TotalCount = ctx.Products.Count(x => CatIds.Contains(x.Category_Id.Value) && x.IsDeleted == false);
products = ctx.Products.Where(x => CatIds.Contains(x.Category_Id.Value) && x.IsDeleted == false).OrderByDescending(x => x.Id).Page(PageSize, PageNo).ToList();
}
else
{
TotalCount = ctx.Products.Count(x => x.Category_Id == CatId && x.IsDeleted == false);
products = ctx.Products.Where(x => x.Category_Id == CatId && x.IsDeleted == false).OrderByDescending(x => x.Id).Page(PageSize, PageNo).ToList();
}
//foreach (var product in products)
//{
// product.Weight = Convert.ToString(product.WeightInGrams) + " gm";
// if (userFavourites.Any(x => x.Product_Id == product.Id))
// product.IsFavourite = true;
// else
// product.IsFavourite = false;
//}
return(Ok(new CustomResponse <ProductsViewModel>
{
Message = ResponseMessages.Success,
StatusCode = (int)HttpStatusCode.OK,
Result = new ProductsViewModel
{
Count = TotalCount,
Products = products
}
}));
}
}
catch (Exception ex)
{
return(StatusCode(DunkeyDelivery.Utility.LogError(ex)));
}
}
public IHttpActionResult RedeemPrize(int UserID, int RewardID)
{
try
{
using (DunkeyContext ctx = new DunkeyContext())
{
var Reward = new RewardMilestones();
var CurrentUser = ctx.Users.Where(x => x.Id == UserID).FirstOrDefault();
Reward = ctx.RewardMilestones.Where(x => x.Id == RewardID).FirstOrDefault();
if (CurrentUser.RewardPoints >= Reward.PointsRequired)
{
var reward = ctx.UserRewards.Add(new UserRewards {
Created_Date = DateTime.Now,
is_deleted = 0,
User_Id = CurrentUser.Id,
RewardMilestones_Id = Reward.Id
});
ctx.SaveChanges();
CurrentUser.RewardPoints = CurrentUser.RewardPoints - Reward.PointsRequired;
ctx.SaveChanges();
CustomResponse <UserRewards> response = new CustomResponse <UserRewards>
{
Message = "Success",
StatusCode = (int)HttpStatusCode.OK,
Result = reward
};
return(Ok(response));
}
return(Content(HttpStatusCode.OK, new CustomResponse <Error>
{
Message = "Forbidden",
StatusCode = (int)HttpStatusCode.Forbidden,
Result = new Error {
ErrorMessage = "Insufficient Points."
}
}));
}
}
catch (Exception ex)
{
return(StatusCode(DunkeyDelivery.Utility.LogError(ex)));
}
}
