public async Task <HttpResponseMessage> UpdateAddressInfo(AddressModel model)
{
try
{
using (HGContext context = new HGContext())
{
var user =
await
context.Users.Include(u => u.Address)
.SingleOrDefaultAsync(u => u.Email == User.Identity.Name);
if (user.Address == null)
{
user.Address = new Address();
}
user.Address.Address1 = model.Address1;
user.Address.Address2 = model.Address2;
user.Address.City = model.City;
user.Address.State = model.State;
context.Entry(user).State = EntityState.Modified;
await context.SaveChangesAsync();
return(Request.CreateResponse(HttpStatusCode.OK));
}
}
catch
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
}
public async Task <HttpResponseMessage> UpdateStateInfo(PatientInfoModel model)
{
List <string> errors = new List <string>();
if (!ModelState.IsValid)
{
errors.AddRange(ModelState.Keys.SelectMany(k => ModelState[k].Errors).Select(m => m.ErrorMessage).ToList());
return(Request.CreateResponse(HttpStatusCode.BadRequest, errors));
}
try
{
using (HGContext context = new HGContext())
{
var user =
await
context.Users.Include(u => u.PatientInfo)
.SingleOrDefaultAsync(u => u.Email == User.Identity.Name);
user.PatientInfo.MedicalCardNumber = model.MedicalCardNumber;
user.PatientInfo.MedicalCardExpirationDate = model.MedicalCardExpirationDate;
user.PatientInfo.ApprovalStatus = ApproalStatus.APPLIED;
context.Entry(user).State = EntityState.Modified;
await context.SaveChangesAsync();
return(Request.CreateResponse(HttpStatusCode.OK));
}
}
catch
{
errors.Add("An error has occured while saving.");
return(Request.CreateResponse(HttpStatusCode.BadRequest, errors.ToArray()));
}
}
private int AddDispensary(DispensaryModel dispensary, Dispensary entity)
{
foreach (string zip in dispensary.ApprovalZipCodes.Split(','))
{
string trimmedZip = zip.Trim();
if (!String.IsNullOrEmpty(trimmedZip))
{
entity.ApprovalZipCodes.Add(HGContext.ZipCodes.Add(new ZipCode()
{
Code = trimmedZip
}));
}
}
foreach (string zip in dispensary.DeliveryZipCodes.Split(','))
{
string trimmedZip = zip.Trim();
if (!String.IsNullOrEmpty(trimmedZip))
{
entity.DeliveryZipCodes.Add(HGContext.ZipCodes.Add(new ZipCode()
{
Code = trimmedZip
}));
}
}
HGContext.Dispensaries.Add(entity);
var id = HGContext.SaveChanges();
return(id);
}
public async Task <HttpResponseMessage> Approve(int id)
{
var dispensary = await HGContext.PendingDispensaries.Include(d => d.Address).SingleOrDefaultAsync(d => d.Id == id);
dispensary.PendingDispensaryStatus = PendingDispensaryStatus.Approved;
HGContext.Entry(dispensary).State = EntityState.Modified;
var password = new Random().Next(100000, 999999);
var guid = Guid.NewGuid().ToString();
var idresult = await UserManager.CreateAsync(new User
{
Email = dispensary.Email,
UserName = dispensary.Email,
Guid = guid,
Zipcode = dispensary.Address == null ? null : dispensary.Address.Zip,
CreatedAt = DateTimeOffset.UtcNow,
UpdatedAt = DateTimeOffset.UtcNow,
LastLogin = DateTimeOffset.UtcNow
}, password.ToString());
if (idresult.Succeeded)
{
var user = await UserManager.FindByEmailAsync(dispensary.Email);
await UserManager.AddToRoleAsync(user.Id, Role.DispensaryManager);
await HGContext.SaveChangesAsync();
await SendVerificationEmail(dispensary.Email, "Your requset has been approved, your password for login is " + password, "Dispensary approved");
return(Request.CreateResponse(HttpStatusCode.OK, dispensary));
}
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
public async Task <HttpResponseMessage> Upload(HttpRequestMessage request)
{
if (!Request.Content.IsMimeMultipartContent())
{
return(Request.CreateResponse(HttpStatusCode.UnsupportedMediaType));
}
HttpFileCollection files = HttpContext.Current.Request.Files;
if (files.Count != 0)
{
byte[] content;
using (MemoryStream ms = new MemoryStream())
{
files[0].InputStream.CopyTo(ms);
content = ms.ToArray();
}
File image = new File()
{
ContentType = files[0].ContentType,
Content = content
};
image = HGContext.Files.Add(image);
await HGContext.SaveChangesAsync();
return(Request.CreateResponse(HttpStatusCode.OK, image.Id));
}
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
private void UpadteDispensary(PendingDispensaryModel pendingDispensary)
{
var entity = HGContext.PendingDispensaries.SingleOrDefault(d => d.Id == pendingDispensary.Id);
entity.Id = pendingDispensary.Id;
entity.AddressId = pendingDispensary.AddressId;
entity.Email = pendingDispensary.Email;
entity.Name = pendingDispensary.Name;
entity.PhoneNumber = pendingDispensary.PhoneNumber;
entity.PendingDispensaryStatus = PendingDispensaryStatus.WaitingForApprove;
entity.Type = pendingDispensary.Type;
entity.Website = pendingDispensary.Website;
HGContext.Entry(entity).State = EntityState.Modified;
var address = HGContext.Addresses.SingleOrDefault(a => a.Id == pendingDispensary.Id);
if (address != null)
{
address.Address1 = pendingDispensary.Address.Address1;
address.Address2 = pendingDispensary.Address.Address2;
address.City = pendingDispensary.Address.City;
address.State = pendingDispensary.Address.State;
address.Zip = pendingDispensary.Address.Zip;
address.Country = pendingDispensary.Address.Country;
HGContext.Entry(address).State = EntityState.Modified;
}
HGContext.SaveChanges();
}
public async Task <IHttpActionResult> SetApproval([FromBody] UserModel user)
{
var uid = HttpContext.Current.User.Identity.GetUserId <int>();
Dictionary <string, string> replaceList = new Dictionary <string, string>();
if (HttpContext.Current.User.IsInRole("GlobalAdmin"))
{
var entity = await HGContext.Users.Include("PatientInfo").FirstOrDefaultAsync(x => x.Id == user.Id);
entity.FirstName = user.FirstName;
entity.LastName = user.LastName;
entity.Birthday = user.Birthday;
if (entity.Address == null)
{
entity.Address = new Address();
}
entity.Address.Address1 = user.Address.Address1;
entity.Address.Address2 = user.Address.Address2;
entity.Address.City = user.Address.City;
entity.Address.State = user.Address.State;
entity.Address.Zip = user.Address.Zip;
entity.Address.Country = "US";
entity.Address.CreatedAt = DateTimeOffset.UtcNow;
entity.Address.UpdatedAt = DateTimeOffset.UtcNow;
entity.PatientInfo.DriversLicenseNumber = user.PatientInfo.DriversLicenseNumber;
entity.PatientInfo.MedicalCardExpirationDate = user.PatientInfo.MedicalCardExpirationDate;
entity.PatientInfo.MedicalCardNumber = user.PatientInfo.MedicalCardNumber;
replaceList.Add("UserName", user.FirstName);
replaceList.Add("LastName", user.LastName);
if (user.PatientInfo.ApprovalStatus == ApproalStatusModel.ACCEPTED)
{
entity.PatientInfo.ApprovalStatus = ApproalStatus.ACCEPTED;
entity.PatientInfo.IsApproved = true;
entity.PatientInfo.MedicalCardValidationDate = DateTime.UtcNow;
replaceList.Add("Status", "APPROVED");
await SendVerificationEmail(user.Email, GetEmailTemplate(replaceList, "RegistrationStatusMail"), "Jane Registration Status");
}
if (user.PatientInfo.ApprovalStatus == ApproalStatusModel.REJECTED)
{
entity.PatientInfo.ApprovalStatus = ApproalStatus.REJECTED;
replaceList.Add("Status", "DISAPPROVED");
await SendVerificationEmail(user.Email, GetEmailTemplate(replaceList, "RegistrationStatusMail"), "Jane Registration Status");
}
var result = await HGContext.SaveChangesAsync();
if (result > 0)
{
return(Ok());
}
else
{
return(BadRequest());
}
}
return(Unauthorized());
}
public ViewResult Details([FromUri] [Required] int id)
{
using (var context = new HGContext())
{
DispensaryProductModel product = context.DispensaryProducts.AsNoTracking()
.Include(p => p.DispensaryProductVariants.Select(v => v.Photos))
.Where(p => !p.IsDeleted && !p.Dispensary.IsDeleted && p.Id == id)
.Select(item => new DispensaryProductModel()
{
Id = item.Id,
Name = item.Name,
Description = item.Description,
Dispensary = new ThinDispensaryModel()
{
Name = item.Dispensary.Name,
Id = item.Dispensary.Id,
Slug = item.Dispensary.Slug
},
ProductCategory =
new ProductCategoryModel() { Id = item.ProductCategory.Id, Name = item.ProductCategory.Name },
DispensaryProductVariants =
item.DispensaryProductVariants.Select(v => new DispensaryProductVariantModel()
{
Id = v.Id,
IsMasterVariant = v.IsMasterVariant,
DisplayOrder = v.DisplayOrder,
Name = v.Name,
Photos = v.Photos.Select(p => new FileModel() { Id = p.Id }),
IsPricedByWeight = v.IsPricedByWeight,
VariantQuantity = v.VariantQuantity,
VariantPricingJSON = v.VariantPricing
}),
Effects = item.Effects.Select(e => new EffectModel() { Id = e.Id, Name = e.Name, Description = e.Description }),
Symptoms = item.Symptoms.Select(e => new SymptomModel() { Id = e.Id, Name = e.Name, Description = e.Description }),
IsAvailable = item.IsAvailable,
IsDiscounted = item.IsDiscounted,
IsPopular = item.IsPopular,
Slug = item.Slug,
YouTubeVideoUrl = item.YouTubeVideoUrl
}).FirstOrDefault();
if (product == null)
throw new HttpException(404, "Can't find product");
foreach (DispensaryProductVariantModel variant in product.DispensaryProductVariants)
{
variant.VariantPricing = Mapper.Map<List<VariantPricing>>(variant.VariantPricingJSON);
}
return View(product);
}
}
#pragma warning disable 1998
public async Task <IHttpActionResult> GetUser()
{
using (HGContext context = new HGContext())
{
var user = context.Users.Include(u => u.PatientInfo).Include(u => u.Address)
.SingleOrDefaultAsync(u => u.Email == User.Identity.Name);
var model = Mapper.Map <UserModel>(user.Result);
return(Ok(model));
}
}
public async Task <HttpResponseMessage> UpdatePendingDispensaryLicense([FromBody] PendingDispensaryModel pendingDispensary)
{
var dispensary = await HGContext.PendingDispensaries.FindAsync(pendingDispensary.Id);
dispensary.IdNumber = pendingDispensary.IdNumber;
dispensary.ExperationDate = pendingDispensary.ExperationDate;
HGContext.Entry(dispensary).State = EntityState.Modified;
await HGContext.SaveChangesAsync();
return(Request.CreateResponse(HttpStatusCode.OK));
}
public ActionResult CompleteData()
{
using (HGContext context = new HGContext())
{
if (context.Dispensaries.Any(d => d.EmailAddress.ToLower() == User.Identity.Name))
{
return(Redirect("/"));
}
}
return(View());
}
public ActionResult CompleteData()
{
using (HGContext context = new HGContext())
{
if (context.Dispensaries.Any(d => d.EmailAddress.ToLower() == User.Identity.Name))
{
return Redirect("/");
}
}
return View();
}
public async Task <HttpResponseMessage> Reject(int id)
{
var dispensary = await HGContext.PendingDispensaries.SingleOrDefaultAsync(d => d.Id == id);
dispensary.PendingDispensaryStatus = PendingDispensaryStatus.Rejected;
HGContext.Entry(dispensary).State = EntityState.Modified;
await HGContext.SaveChangesAsync();
await SendVerificationEmail(dispensary.Email, "Your requset has been rejected", "Dispensary rejected");
return(Request.CreateResponse(HttpStatusCode.OK, dispensary));
}
public void Delete([FromUri] int id)
{
Dispensary dispensary = HGContext.Dispensaries.Include(d => d.DispensaryProducts).FirstOrDefault(d => d.Id == id);
foreach (DispensaryProduct product in dispensary.DispensaryProducts)
{
product.IsDeleted = true;
}
dispensary.IsDeleted = true;
HGContext.SaveChanges();
}
public async Task <IHttpActionResult> Logout(string usertoken, string sessiontoken)
{
var user = await HGContext.Users.Include("UserSessions").FirstOrDefaultAsync(x => x.Guid == usertoken);
var session = await HGContext.Sessions.FirstOrDefaultAsync(x => x.Token == sessiontoken);
var usersession = await HGContext.UserSessions.FirstOrDefaultAsync(x => x.SessionId == session.Id);
var sessionresult = HGContext.Sessions.Remove(session);
var usersessionresult = HGContext.UserSessions.Remove(usersession);
var result = await HGContext.SaveChangesAsync();
return(Ok());
}
public async Task <HttpResponseMessage> UpdateUserDocuments(PatientInfoModel model)
{
var user =
await
HGContext.Users.Include(u => u.PatientInfo)
.SingleOrDefaultAsync(u => u.Email == User.Identity.Name);
user.PatientInfo.DriversLicenseImageUrl = model.DriversLicenseImageUrl;
user.PatientInfo.RecommendationImageUrl = model.RecommendationImageUrl;
HGContext.Entry(user).State = EntityState.Modified;
await HGContext.SaveChangesAsync();
return(Request.CreateResponse(HttpStatusCode.OK));
}
public async Task <IHttpActionResult> SubmitApplication([FromBody] UserModel user)
{
var uid = HttpContext.Current.User.Identity.GetUserId <int>();
if (uid == user.Id || HttpContext.Current.User.IsInRole("GlobalAdmin"))
{
var entity = await HGContext.Users.FirstOrDefaultAsync(x => x.Id == user.Id);
if (!string.IsNullOrWhiteSpace(user.FirstName))
{
entity.FirstName = user.FirstName;
}
if (!string.IsNullOrWhiteSpace(user.LastName))
{
entity.LastName = user.LastName;
}
if (!string.IsNullOrWhiteSpace(user.Zipcode))
{
entity.Zipcode = user.Zipcode;
}
if (!string.IsNullOrWhiteSpace(user.PhoneNumber))
{
entity.PhoneNumber = user.PhoneNumber;
}
entity.Birthday = user.Birthday;
var result = await HGContext.SaveChangesAsync();
if (ValidatePatientApplication(entity) && entity.PatientInfo.ApprovalStatus != ApproalStatus.APPLIED &&
entity.PatientInfo.ApprovalStatus != ApproalStatus.ACCEPTED)
{
entity.PatientInfo.ApprovalStatus = ApproalStatus.APPLIED;
var applicationresult = await HGContext.SaveChangesAsync();
//Send email to user and to AskMJane to process patient application
await SendEmailConfirmationToPatient(entity);
await SendEmailConfirmationToAskMJane(entity);
return(Ok());
}
else
{
return(BadRequest("Patient Application was not completed."));
}
}
else
{
return(Unauthorized());
}
}
public async Task <HttpResponseMessage> UpdatePendingDispensaryDocuments([FromBody] PendingDispensaryModel pendingDispensary)
{
var dispensary = await HGContext.PendingDispensaries.FindAsync(pendingDispensary.Id);
dispensary.DriversLicenseImageUrl = pendingDispensary.DriversLicenseImageUrl;
dispensary.RecommendationImageUrl = pendingDispensary.RecommendationImageUrl;
dispensary.PendingDispensaryStatus = PendingDispensaryStatus.WaitingForApprove;
HGContext.Entry(dispensary).State = EntityState.Modified;
await HGContext.SaveChangesAsync();
await SendVerifyEmaiForSuperAdminAccounts(dispensary);
return(Request.CreateResponse(HttpStatusCode.OK));
}
public async Task <IHttpActionResult> SetRxUrl(SetPathBindingModel model)
{
try
{
var entity = await HGContext.PatientInfos.FirstOrDefaultAsync(x => x.Id == model.Id);
entity.RecommendationImageUrl = model.Path;
var response = await HGContext.SaveChangesAsync();
return(Ok());
}
catch
{
_logger.ErrorFormat("Error while updating PatientInfo Id: {0} RxUrl: {1}", model.Id, model.Path);
return(BadRequest());
}
}
public IHttpActionResult EditCredits([FromBody] EditCredit credit)
{
var wallet = HGContext.Users.Where(u => u.Id == credit.userId).Select(u => u.Wallet).FirstOrDefault();
if (wallet != null)
{
wallet.Credit = credit.amount;
}
else
{
return(NotFound());
}
HGContext.SaveChanges();
return(Ok());
}
public async Task <IHttpActionResult> SetIdUrl(SetPathBindingModel model)
{
var entity = await HGContext.PatientInfos.FirstOrDefaultAsync(x => x.Id == model.Id);
entity.DriversLicenseImageUrl = model.Path;
var response = await HGContext.SaveChangesAsync();
if (response > 0)
{
return(Ok());
}
else
{
_logger.ErrorFormat("Error while updating PatientInfo Id: {0} PhotoIdUrl: {1}", model.Id, model.Path);
return(BadRequest());
}
}
public async Task <HttpResponseMessage> ShowDispensary([FromUri] int id)
{
try
{
var dispensary = await HGContext.Dispensaries.SingleOrDefaultAsync(d => d.Id == id && !d.IsDeleted);
dispensary.IsHidden = false;
HGContext.Entry(dispensary).State = EntityState.Modified;
await HGContext.SaveChangesAsync();
return(Request.CreateResponse(HttpStatusCode.OK));
}
catch (Exception)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
}
public async Task <HttpResponseMessage> Delete([FromUri] int id)
{
var entity = await HGContext.DispensaryProducts.FirstOrDefaultAsync(x => x.Id == id);
entity.IsDeleted = true;
entity.UpdatedAt = DateTimeOffset.UtcNow;
var res = await HGContext.SaveChangesAsync();
if (res > 0)
{
return(Request.CreateResponse(HttpStatusCode.OK));
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Unable to remove product"));
}
}
public async Task <HttpResponseMessage> Update([FromBody] ProductModel model)
{
try
{
var entity =
await
HGContext.Products.Include(prod => prod.Photos).FirstOrDefaultAsync(x => x.Id == model.Id);
entity.Name = model.Name;
entity.Slug = model.Slug;
entity.YouTubeVideoUrl = YouTubeVideoHelper.TransformYouTubeVideo(model.YouTubeVideoUrl);
entity.LeaflySlug = model.LeaflySlug ?? model.Name;
entity.Description = model.Description;
entity.UpdatedAt = DateTimeOffset.UtcNow;
entity.ProductCategory = HGContext.ProductCategories.FirstOrDefault(c => c.Id == model.ProductCategoryId);
List <int> ids = model.Effects.Select(e => e.Id).ToList();
entity.Effects.Clear();
entity.Effects = HGContext.Effects.Where(e => ids.Contains(e.Id)).ToList();
ids = model.Symptoms.Select(e => e.Id).ToList();
entity.Symptoms.Clear();
entity.Symptoms = HGContext.Symptoms.Where(e => ids.Contains(e.Id)).ToList();
ids = model.Photos.Select(p => p.Id).ToList();
entity.Photos.Clear();
entity.Photos = HGContext.Files.Where(i => ids.Contains(i.Id)).ToList();
var statusCode = await HGContext.SaveChangesAsync();
if (statusCode > 0)
{
return(Request.CreateResponse(HttpStatusCode.OK));
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Unable to save product"));
}
}
catch (Exception e)
{
_logger.Error("DispensaryProduct.Update", e);
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, e));
}
}
public async Task <HttpResponseMessage> RemoveFromCart(int id)
{
var entity = await HGContext.DispensaryProductVariantOrders.FirstOrDefaultAsync(x => x.Id == id);
var removeEntity = HGContext.DispensaryProductVariantOrders.Remove(entity);
var orderentity = await HGContext.Orders.FirstOrDefaultAsync(x => x.Id == entity.OrderId);
orderentity.UpdatedAt = DateTimeOffset.UtcNow;
var response = await HGContext.SaveChangesAsync();
if (response > 0)
{
return(Request.CreateResponse(HttpStatusCode.OK));
}
else
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, id));
}
}
public ViewResult Details([FromUri] [Required] int id)
{
//DispensaryModel model;
using (var context = new HGContext())
{
DispensaryModel disp = context.Dispensaries
.AsNoTracking().Where(d => !d.IsDeleted && d.Id == id).Select(d => new DispensaryModel()
{
Address = new AddressModel() { FormattedAddress = d.Address.FormattedAddress },
Description = d.Description,
EmailAddress = d.EmailAddress,
Name = d.Name,
PhoneNumber = d.PhoneNumber,
Type = d.Type
})
.FirstOrDefault();
return View(disp);
}
}
public async Task <HttpResponseMessage> UpdatePhotos([FromBody] UpdatePhotoBindingModel model)
{
var entity = await HGContext.DispensaryProductVariants.Include(v => v.Photos).FirstOrDefaultAsync(x => x.Id == model.Id);
if (entity == null)
{
return(Request.CreateResponse(HttpStatusCode.NotFound));
}
List <int> ids = model.Photos.Select(p => p.Id).ToList();
List <File> images = HGContext.Files.Where(i => ids.FirstOrDefault(p => p == i.Id) != 0).ToList();
if (entity.Photos != null && entity.Photos.Any())
{
ids = entity.Photos.Select(p => p.Id).ToList();
images.RemoveAll(i => ids.FirstOrDefault(id => id == i.Id) != 0);
}
if (!images.Any())
{
return(Request.CreateResponse(HttpStatusCode.OK));
}
if (entity.Photos == null)
{
entity.Photos = new List <File>();
}
entity.Photos.AddRange(images);
var res = await HGContext.SaveChangesAsync();
if (res > 0)
{
return(Request.CreateResponse(HttpStatusCode.OK));
}
else
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
}
public async Task <IHttpActionResult> Fund([FromBody] FundWalletBindingModel model)
{
StripeService stripe = new StripeService();
var response = await stripe.ChargeCustomer(model.StripeToken, model.TransactionAmount);
if (response)
{
var user = await HGContext.Users.FirstOrDefaultAsync(x => x.Id == model.UserId);
var wallet = await HGContext.Wallets.FirstOrDefaultAsync(x => x.Id == model.WalletId);
if (wallet != null && user.WalletId == wallet.Id)
{
wallet.Transactions.Add(new Transaction()
{
TransactedAt = DateTimeOffset.UtcNow,
TransactionAmount = model.TransactionAmount / 100M,
TransactionCharge = 0M,
TransactionStatus = TransactionStatusEnum.CLEARED,
TransactionType = TransactionTypeEnum.DEPOSIT
});
var result = HGContext.SaveChanges();
if (result == 0)
{
return(BadRequest("Something went wrong"));
}
return(Ok());
}
return(BadRequest("Something went wrong"));
}
else
{
_logger.ErrorFormat("Failed to finalize payment user {0} amount {1}", model.UserId, model.TransactionAmount);
return(BadRequest("Something went wrong"));
}
//return Ok(response);
}
public async Task <HttpResponseMessage> Post([FromBody] ProductModel product)
{
try
{
var entity = Mapper.Map <Product>(product);
List <int> ids;
ids = entity.Effects.Select(e => e.Id).ToList();
entity.Effects =
HGContext.Effects.Where(e => ids.Contains(e.Id)).ToList();
entity.ProductCategory =
HGContext.ProductCategories.FirstOrDefault(c => c.Id == product.ProductCategoryId);
ids = product.Photos.Select(p => p.Id).ToList();
entity.Photos.Clear();
entity.Photos = HGContext.Files.Where(i => ids.Contains(i.Id)).ToList();
HGContext.Products.Add(entity);
var id = await HGContext.SaveChangesAsync();
if (id > 0)
{
return(Request.CreateResponse(Mapper.Map <ProductModel>(HGContext.Products.FirstOrDefault(x => x.Id == id))));
}
else
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, product));
}
}
catch (Exception e)
{
_logger.Error("Products.Post", e);
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, e));
}
}
public IHttpActionResult UpdateUserRoles(UserWithRolesModel user)
{
User userInfo = HGContext.Users.Include(u => u.Roles).FirstOrDefault(u => u.Id == user.Id);
if (userInfo == null)
{
return(NotFound());
}
var ids = user.RolesList.Select(r => r.Id).ToList();
userInfo.Roles.Clear();
foreach (int id in ids)
{
userInfo.Roles.Add(new UserRole()
{
UserId = user.Id, RoleId = id
});
}
HGContext.SaveChanges();
return(Ok());
}
public ViewResult Details([FromUri][Required] int id)
{
//DispensaryModel model;
using (var context = new HGContext())
{
DispensaryModel disp = context.Dispensaries
.AsNoTracking().Where(d => !d.IsDeleted && d.Id == id).Select(d => new DispensaryModel()
{
Address = new AddressModel()
{
FormattedAddress = d.Address.FormattedAddress
},
Description = d.Description,
EmailAddress = d.EmailAddress,
Name = d.Name,
PhoneNumber = d.PhoneNumber,
Type = d.Type
})
.FirstOrDefault();
return(View(disp));
}
}
public async Task <IHttpActionResult> ConfirmPhoneNumber([FromUri] int id, [FromUri] string phonenumber)
{
var uid = HttpContext.Current.User.Identity.GetUserId <int>();
if (uid == id || HttpContext.Current.User.IsInRole("GlobalAdmin"))
{
var entity = await HGContext.Users.FirstOrDefaultAsync(x => x.Id == id);
entity.PhoneNumber = phonenumber;
entity.PhoneNumberConfirmed = true;
var result = await HGContext.SaveChangesAsync();
if (result > 0)
{
return(Ok());
}
else
{
return(BadRequest());
}
}
return(Unauthorized());
}
public async Task <HttpResponseMessage> UpdateQuantity(int id, int qty)
{
var entity = await HGContext.DispensaryProductVariantOrders.FirstOrDefaultAsync(x => x.Id == id);
// var removeEntity = HGContext.DispensaryProductVariantOrders.Remove(entity);
entity.Quantity = qty;
entity.TotalPrice = qty * entity.UnitPrice;
entity.UpdatedAt = DateTimeOffset.UtcNow;
var response = await HGContext.SaveChangesAsync();
var orderentity = await HGContext.Orders.FirstOrDefaultAsync(x => x.Id == entity.OrderId);
orderentity.UpdatedAt = DateTimeOffset.UtcNow;
var response2 = await HGContext.SaveChangesAsync();
if (response > 0 && response2 > 0)
{
return(Request.CreateResponse(HttpStatusCode.OK));
}
else
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, id));
}
}
public async Task<HttpResponseMessage> UpdateAddressInfo(AddressModel model)
{
try
{
using (HGContext context = new HGContext())
{
var user =
await
context.Users.Include(u => u.Address)
.SingleOrDefaultAsync(u => u.Email == User.Identity.Name);
if (user.Address == null)
{
user.Address = new Address();
}
user.Address.Address1 = model.Address1;
user.Address.Address2 = model.Address2;
user.Address.City = model.City;
user.Address.State = model.State;
context.Entry(user).State = EntityState.Modified;
await context.SaveChangesAsync();
return Request.CreateResponse(HttpStatusCode.OK);
}
}
catch
{
return Request.CreateResponse(HttpStatusCode.BadRequest);
}
}
public async Task<HttpResponseMessage> UpdateStateInfo(PatientInfoModel model)
{
List<string> errors = new List<string>();
if (!ModelState.IsValid)
{
errors.AddRange(ModelState.Keys.SelectMany(k => ModelState[k].Errors).Select(m => m.ErrorMessage).ToList());
return Request.CreateResponse(HttpStatusCode.BadRequest, errors);
}
try
{
using (HGContext context = new HGContext())
{
var user =
await
context.Users.Include(u => u.PatientInfo)
.SingleOrDefaultAsync(u => u.Email == User.Identity.Name);
user.PatientInfo.MedicalCardNumber = model.MedicalCardNumber;
user.PatientInfo.MedicalCardExpirationDate = model.MedicalCardExpirationDate;
user.PatientInfo.ApprovalStatus = ApproalStatus.APPLIED;
context.Entry(user).State = EntityState.Modified;
await context.SaveChangesAsync();
return Request.CreateResponse(HttpStatusCode.OK);
}
}
catch
{
errors.Add("An error has occured while saving.");
return Request.CreateResponse(HttpStatusCode.BadRequest, errors.ToArray());
}
}
#pragma warning disable 1998
public async Task<IHttpActionResult> GetUser()
{
using (HGContext context = new HGContext())
{
var user = context.Users.Include(u => u.PatientInfo).Include(u => u.Address)
.SingleOrDefaultAsync(u => u.Email == User.Identity.Name);
var model = Mapper.Map<UserModel>(user.Result);
return Ok(model);
}
}
public AuthRepository()
{
_ctx = new HGContext();
_userManager = new UserManager<User,int>(new UserStore<User,int>(_ctx));
}
public HGRepo()
{
context = new HGContext();
}
public HGRepo(HGContext _context)
{
context = _context;
}
