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> 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));
}
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> 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()));
}
}
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 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 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 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> 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 <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> 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 <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 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> 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> 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> 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 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 <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 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> Update([FromBody] DispensaryModel dispensary)
{
try
{
var entity = await HGContext.Dispensaries.FirstOrDefaultAsync(x => x.Id == dispensary.Id);
entity.Name = dispensary.Name;
entity.Slug = dispensary.Name;
entity.Type = dispensary.Type;
entity.PhoneNumber = dispensary.PhoneNumber;
entity.LeaflySlug = dispensary.LeaflySlug ?? dispensary.Name;
entity.Description = dispensary.Description;
entity.HoursOfOperation = Mapper.Map <string>(dispensary.HoursOfOperation);
entity.HoursAndInfo = dispensary.HoursAndInfo;
entity.EmailAddress = dispensary.EmailAddress;
entity.HasDelivery = dispensary.HasDelivery;
entity.HasPickup = dispensary.HasPickup;
entity.HasStorefront = dispensary.HasStorefront;
entity.IsCaregiver = dispensary.IsCaregiver;
entity.IsPrivate = dispensary.IsPrivate;
if (dispensary.Address != null && (!string.IsNullOrEmpty(dispensary.Address.Zip) || !string.IsNullOrEmpty(dispensary.Address.City) ||
!string.IsNullOrEmpty(dispensary.Address.State)))
{
if (entity.Address == null)
{
entity.Address = new Address();
}
entity.Address.Address1 = dispensary.Address.Address1;
entity.Address.Address2 = dispensary.Address.Address2;
entity.Address.City = dispensary.Address.City;
entity.Address.State = dispensary.Address.State;
entity.Address.Zip = dispensary.Address.Zip;
entity.Address.Name = dispensary.Name;
entity.Address.Latitude = dispensary.Address.Latitude;
entity.Address.Longitude = dispensary.Address.Longitude;
entity.Address.FormattedAddress = dispensary.Address.FormattedAddress;
}
HGContext.ZipCodes.RemoveRange(entity.ApprovalZipCodes);
if (dispensary.ApprovalZipCodes != null)
{
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
}));
}
}
}
HGContext.ZipCodes.RemoveRange(entity.DeliveryZipCodes);
if (dispensary.DeliveryZipCodes != null)
{
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
}));
}
}
}
var id = await HGContext.SaveChangesAsync();
if (id > 0)
{
return(Request.CreateResponse(HttpStatusCode.OK));
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Unable to save dispensary"));
}
}
catch (Exception e)
{
_logger.Error("Dispensaries.Post", e);
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, e));
}
}
public async Task <HttpResponseMessage> Update([FromBody] DispensaryProductModel model)
{
try
{
foreach (var v in model.DispensaryProductVariants)
{
foreach (var p in v.VariantPricing)
{
if (v.IsPricedByWeight)
{
var oz = p.Weight / 28M;
if (1 / 28M == oz)
{
p.DisplayWeight = "Gram";
}
else if (.125M == oz)
{
p.DisplayWeight = "Eighth";
}
else if (.25M == oz)
{
p.DisplayWeight = "Quarter";
}
else if (.5M == oz)
{
p.DisplayWeight = "Half";
}
else if (1M == oz)
{
p.DisplayWeight = "Ounce";
}
else
{
p.DisplayWeight = String.Format("{0}g", p.Weight);
}
}
else
{
if (1M == p.Weight)
{
p.DisplayWeight = "Each";
}
else
{
p.DisplayWeight = String.Format("{0}-pack", p.Weight);
}
}
}
}
var entity =
await
HGContext.DispensaryProducts.Include(product => product.DispensaryProductVariants)
.Include(product => product.DispensaryProductVariants.Select(variant => variant.Photos))
.FirstOrDefaultAsync(x => x.Id == model.Id);
entity.Name = model.Name;
entity.Slug = model.Slug;
entity.LeaflySlug = model.LeaflySlug ?? model.Name;
entity.Description = model.Description;
entity.UpdatedAt = DateTimeOffset.UtcNow;
entity.YouTubeVideoUrl = YouTubeVideoHelper.TransformYouTubeVideo(model.YouTubeVideoUrl);
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();
entity.DispensaryProductVariants.ForEach(v => v.IsDeleted = true);
foreach (DispensaryProductVariantModel variant in model.DispensaryProductVariants)
{
DispensaryProductVariant variantEntity =
entity.DispensaryProductVariants.FirstOrDefault(v => v.Id == variant.Id);
if (variantEntity != null)
{
variantEntity.IsDeleted = false;
ids = variant.Photos.Select(p => p.Id).ToList();
List <File> images =
HGContext.Files.Where(i => ids.FirstOrDefault(p => p == i.Id) != 0).ToList();
if (variantEntity.Photos == null)
{
variantEntity.Photos = new List <File>();
}
variantEntity.Photos.Clear();
variantEntity.Photos.AddRange(images);
variantEntity.VariantPricing = Mapper.Map <string>(variant.VariantPricing);
}
}
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));
}
}
// POST: api/Dispensaries
public async Task <HttpResponseMessage> Post([FromBody] DispensaryProductModel product)
{
try
{
foreach (var v in product.DispensaryProductVariants)
{
foreach (var p in v.VariantPricing)
{
if (v.IsPricedByWeight)
{
var oz = p.Weight / 28M;
if (1 / 28M == oz)
{
p.DisplayWeight = "Gram";
}
else if (.125M == oz)
{
p.DisplayWeight = "Eighth";
}
else if (.25M == oz)
{
p.DisplayWeight = "Quarter";
}
else if (.5M == oz)
{
p.DisplayWeight = "Half";
}
else if (1M == oz)
{
p.DisplayWeight = "Ounce";
}
else
{
p.DisplayWeight = String.Format("{0}g", p.Weight);
}
}
else
{
if (1M == p.Weight)
{
p.DisplayWeight = "Each";
}
else
{
p.DisplayWeight = String.Format("{0}-pack", p.Weight);
}
}
}
}
var entity = Mapper.Map <DispensaryProduct>(product);
List <int> ids;
foreach (DispensaryProductVariant variant in entity.DispensaryProductVariants)
{
ids = variant.Photos.Select(p => p.Id).ToList();
variant.Photos = HGContext.Files.Where(i => ids.Contains(i.Id)).ToList();
}
ids = entity.Effects.Select(e => e.Id).ToList();
entity.Effects =
HGContext.Effects.Where(e => ids.Contains(e.Id)).ToList();
ids = entity.Symptoms.Select(e => e.Id).ToList();
entity.Symptoms =
HGContext.Symptoms.Where(e => ids.Contains(e.Id)).ToList();
entity.YouTubeVideoUrl = YouTubeVideoHelper.TransformYouTubeVideo(entity.YouTubeVideoUrl);
entity.ProductCategory =
HGContext.ProductCategories.FirstOrDefault(cat => cat.Id == product.ProductCategoryId);
HGContext.DispensaryProducts.Add(entity);
var id = await HGContext.SaveChangesAsync();
if (id > 0)
{
return(Request.CreateResponse(Mapper.Map <DispensaryProductModel>(HGContext.DispensaryProducts.FirstOrDefault(x => x.Id == id))));
}
else
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, product));
}
}
catch (Exception e)
{
_logger.Error("Dispensaries.Post", e);
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, e));
}
}
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());
}
}
public async Task <HttpResponseMessage> Login(UserModel login)
{
var email = string.IsNullOrEmpty(login.Email) ? login.Username : login.Email;
var dispensary =
await
HGContext.PendingDispensaries.Include(d => d.Address).SingleOrDefaultAsync(
d =>
d.Email.ToLower() == email.ToLower() &&
d.PendingDispensaryStatus == PendingDispensaryStatus.WaitingForApprove);
if (dispensary != null)
{
var result = UserManager.PasswordHasher.VerifyHashedPassword(dispensary.Password, login.Password);
if (result == PasswordVerificationResult.Success)
{
return(Request.CreateResponse(HttpStatusCode.OK, dispensary));
}
}
var request = HttpContext.Current.Request;
var tokenServiceUrl = request.Url.GetLeftPart(UriPartial.Authority) + request.ApplicationPath + "token";
_logger.DebugFormat("{0} {1} {2} {3}", tokenServiceUrl, request.Url, request.Url.GetLeftPart(UriPartial.Authority), request.ApplicationPath);
using (var client = new HttpClient())
{
var requestParams = new List <KeyValuePair <string, string> >
{
new KeyValuePair <string, string>("grant_type", "password"),
new KeyValuePair <string, string>("username", login.Username ?? login.Email),
new KeyValuePair <string, string>("password", login.Password)
};
var requestParamsFormUrlEncoded = new FormUrlEncodedContent(requestParams);
_logger.DebugFormat("{0} {1} {2} {3}", tokenServiceUrl, requestParams[0], requestParams[1], requestParams[2]);
var tokenServiceResponse = await client.PostAsync(tokenServiceUrl, requestParamsFormUrlEncoded);
var responseString = await tokenServiceResponse.Content.ReadAsStringAsync();
var responseCode = tokenServiceResponse.StatusCode;
_logger.DebugFormat("{0} {1}", responseString, responseCode);
var responseObj = JObject.Parse(responseString);
if (responseCode == HttpStatusCode.OK)
{
try
{
User user = null;
if (login.Email != null && !login.Email.IsNullOrWhiteSpace())
{
user =
await
HGContext.Users.Include("UserSessions")
.FirstOrDefaultAsync(x => x.Email == login.Email);
}
else
{
user =
await
HGContext.Users.Include("UserSessions")
.FirstOrDefaultAsync(x => x.UserName == login.Username);
}
if (!await UserManager.IsInRoleAsync(user.Id, Role.DispensaryManager))
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, new List <string> {
"You seems to be a regular user, please login from regular login screen"
}));
}
responseObj["usertoken"] = user.Guid;
var sessiontoken = Guid.NewGuid().ToString();
user.UserSessions.Add(new UserSession()
{
Session = new Session()
{
LastSeen = DateTimeOffset.UtcNow,
Token = sessiontoken
},
UserId = user.Id
});
var result = await HGContext.SaveChangesAsync();
if (result == 0)
{
_logger.ErrorFormat("Login: Create Session failed -- UserId: {0} Guid: {1}", user.Id,
user.Guid);
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
responseObj["sessiontoken"] = sessiontoken;
var anonuser = await HGContext.Users.FirstOrDefaultAsync(x => x.Guid == login.Guid);
if (user.Id != anonuser.Id && string.IsNullOrWhiteSpace(anonuser.PasswordHash))
{
var cart = await HGContext.Orders.FirstOrDefaultAsync(x =>
x.UserId == user.Id && x.IsCheckedOut == false &&
x.DispensaryProductVariantOrders.Count > 0);
//Set Anonymous user cart to user cart
var anoncart = await HGContext.Orders.FirstOrDefaultAsync(x => x.UserId == anonuser.Id &&
x.IsCheckedOut == false &&
x
.DispensaryProductVariantOrders
.Count > 0);
if (anoncart != null)
{
anoncart.UserId = user.Id;
anoncart.UpdatedAt = DateTimeOffset.UtcNow;
var cartresult = await HGContext.SaveChangesAsync();
if (cartresult == 0)
{
_logger.ErrorFormat(
"Login: Anonymous Cart swap failed -- CartId: {2} UserId: {0} Guid: {1}",
anonuser.Id, anonuser.Guid, anoncart.Id);
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
}
HGContext.Users.Remove(anonuser);
var anonuserresult = await HGContext.SaveChangesAsync();
if (anonuserresult == 0)
{
_logger.ErrorFormat("Login: Anonymous User removal failed -- Id: {0} Guid: {1}",
anonuser.Id, anonuser.Guid);
}
}
if (await UserManager.IsInRoleAsync(user.Id, Role.DispensaryManager))
{
if (
!await
HGContext.Dispensaries.AnyAsync(
d => d.EmailAddress.ToLower() == user.Email.ToLower()))
{
responseObj.Add("notCompleted", true);
}
else
{
responseObj.Add("notCompleted", false);
}
}
}
catch (Exception e)
{
_logger.ErrorFormat("Login error {0}", e);
}
}
else
{
var error = new List <string>()
{
"The username or password is incorrect."
};
return(Request.CreateResponse(responseCode, error));
}
var response = Request.CreateResponse(responseCode, responseObj);
response.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
return(response);
}
}
public async Task <HttpResponseMessage> AddPendingDispensary([FromBody] PendingDispensaryModel pendingDispensary)
{
bool addressFlag = false;
if (!ModelState.IsValid)
{
var errors = ModelState.Keys.SelectMany(k => ModelState[k].Errors).Select(m => m.ErrorMessage).ToArray();
var addressKey = ModelState.Where(x => x.Value.Errors.Count > 0 && x.Key.Contains("AddressId")).Select(x => new { x.Key, x.Value.Errors }).FirstOrDefault();
if (pendingDispensary.Id != 0)
{
bool flag = false;
foreach (var error in errors)
{
if (!error.ToLower().Contains("password"))
{
flag = true;
}
}
if (!flag)
{
UpadteDispensary(pendingDispensary);
return(Request.CreateResponse(HttpStatusCode.OK));
}
}
if (errors.Length <= 1 && addressKey != null)
{
addressFlag = true;
}
else
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, errors));
}
}
if (await HGContext.PendingDispensaries.AnyAsync(p => p.Email.ToLower() == pendingDispensary.Email.ToLower()) || await HGContext.Users.AnyAsync(p => p.Email.ToLower() == pendingDispensary.Email.ToLower()) ||
await HGContext.Dispensaries.AnyAsync(p => p.EmailAddress.ToLower() == pendingDispensary.Email.ToLower()))
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, new[] { pendingDispensary.Email + " is already exist." }));
}
if (addressFlag)
{
/*Add Data in Address Table*/
var Address = new Address()
{
Name = pendingDispensary.Address.Name,
Address1 = pendingDispensary.Address.Address1,
Address2 = pendingDispensary.Address.Address2,
City = pendingDispensary.Address.City,
State = pendingDispensary.Address.State,
Zip = pendingDispensary.Address.Zip,
Country = pendingDispensary.Address.Country,
CreatedAt = DateTimeOffset.UtcNow,
UpdatedAt = DateTimeOffset.UtcNow
};
HGContext.Addresses.Add(Address);
await HGContext.SaveChangesAsync();
pendingDispensary.AddressId = Address.Id;
}
//TODO: Replace these line using automapper
var entity = AutoMapModelToEntity(pendingDispensary);
HGContext.PendingDispensaries.Add(entity);
await HGContext.SaveChangesAsync();
//await SendVerifyEmaiForSuperAdminAccounts(entity);
string webUrl = ConfigurationManager.AppSettings["webclientURL"];
await
SendVerificationEmail(entity.Email,
"Your application has been submitted, please login <a href='" + webUrl + "/dispensary/login'>here</a> and complete your data to active your account", "Dispensary registeration");
return(Request.CreateResponse(HttpStatusCode.OK, entity));
}
public async Task <HttpResponseMessage> Login(UserModel login)
{
//var body = "<p>Email From: {0} ({1})</p><p>Message:</p><p>{2}</p>";
//var message = new MailMessage();
//message.To.Add(new MailAddress("*****@*****.**")); // replace with valid value
//message.From = new MailAddress("*****@*****.**"); // replace with valid value
//message.Subject = "Your email subject";
//message.Body = string.Format(body, "AskMJane", "*****@*****.**", "hi");
//message.IsBodyHtml = true;
//using (var smtp = new SmtpClient())
//{
// var credential = new NetworkCredential
// {
// UserName = "******", // replace with valid value
// Password = "******" // replace with valid value
// };
// smtp.Credentials = credential;
// smtp.Host = "smtp-mail.outlook.com";
// smtp.Port = 587;
// smtp.EnableSsl = true;
// await smtp.SendMailAsync(message);
//}
var request = HttpContext.Current.Request;
var tokenServiceUrl = request.Url.GetLeftPart(UriPartial.Authority) + request.ApplicationPath + "token";
_logger.DebugFormat("{0} {1} {2} {3}", tokenServiceUrl, request.Url, request.Url.GetLeftPart(UriPartial.Authority), request.ApplicationPath);
using (var client = new HttpClient())
{
var requestParams = new List <KeyValuePair <string, string> >
{
// new KeyValuePair<string, string>("grant_type", "password"),
new KeyValuePair <string, string>("username", login.Username ?? login.Email),
//new KeyValuePair<string, string>("password", login.Password)
};
var requestParamsFormUrlEncoded = new FormUrlEncodedContent(requestParams);
_logger.DebugFormat("{0} {1} {2} {3}", tokenServiceUrl, requestParams[0], requestParams[1], requestParams[2]);
var tokenServiceResponse = await client.PostAsync(tokenServiceUrl, requestParamsFormUrlEncoded);
var responseString = await tokenServiceResponse.Content.ReadAsStringAsync();
var responseCode = tokenServiceResponse.StatusCode;
_logger.DebugFormat("{0} {1}", responseString, responseCode);
var responseObj = JObject.Parse(responseString);
if (responseCode == HttpStatusCode.OK)
{
try
{
User user = null;
if (login.Email != null && !login.Email.IsNullOrWhiteSpace())
{
user =
await
HGContext.Users.Include("UserSessions")
.FirstOrDefaultAsync(x => x.Email == login.Email);
}
else
{
user =
await
HGContext.Users.Include("UserSessions")
.FirstOrDefaultAsync(x => x.UserName == login.Username);
}
if (await UserManager.IsInRoleAsync(user.Id, Role.DispensaryManager))
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, new List <string> {
"You seems to be a dispensary manager, try to login from dispensary login screen."
}));
}
responseObj["usertoken"] = user.Guid;
var sessiontoken = Guid.NewGuid().ToString();
user.UserSessions.Add(new UserSession()
{
Session = new Session()
{
LastSeen = DateTimeOffset.UtcNow,
Token = sessiontoken
},
UserId = user.Id
});
var result = await HGContext.SaveChangesAsync();
if (result == 0)
{
_logger.ErrorFormat("Login: Create Session failed -- UserId: {0} Guid: {1}", user.Id,
user.Guid);
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
responseObj["sessiontoken"] = sessiontoken;
var anonuser = await HGContext.Users.FirstOrDefaultAsync(x => x.Guid == login.Guid);
if (user.Id != anonuser.Id && string.IsNullOrWhiteSpace(anonuser.PasswordHash))
{
var cart = await HGContext.Orders.FirstOrDefaultAsync(x =>
x.UserId == user.Id && x.IsCheckedOut == false &&
x.DispensaryProductVariantOrders.Count > 0);
//Set Anonymous user cart to user cart
var anoncart = await HGContext.Orders.FirstOrDefaultAsync(x => x.UserId == anonuser.Id &&
x.IsCheckedOut == false &&
x.DispensaryProductVariantOrders.Count > 0);
if (anoncart != null)
{
anoncart.UserId = user.Id;
anoncart.UpdatedAt = DateTimeOffset.UtcNow;
var cartresult = await HGContext.SaveChangesAsync();
if (cartresult == 0)
{
_logger.ErrorFormat(
"Login: Anonymous Cart swap failed -- CartId: {2} UserId: {0} Guid: {1}",
anonuser.Id, anonuser.Guid, anoncart.Id);
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
}
HGContext.Users.Remove(anonuser);
var anonuserresult = await HGContext.SaveChangesAsync();
if (anonuserresult == 0)
{
_logger.ErrorFormat("Login: Anonymous User removal failed -- Id: {0} Guid: {1}",
anonuser.Id, anonuser.Guid);
}
}
}
catch (Exception e)
{
_logger.ErrorFormat("Login error {0}", e);
}
}
else
{
var error = new List <string>()
{
"The username or password is incorrect."
};
return(Request.CreateResponse(responseCode, error));
}
var response = Request.CreateResponse(responseCode, responseObj);
response.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
return(response);
}
}
public async Task <HttpResponseMessage> AddToCart(AddToCartBindingModel model)
{
var cartEntity = await GetUserCart(model.UserId);
if (cartEntity == null)
{
cartEntity = new Order()
{
UserId = model.UserId,
IsCheckedOut = false,
IsConfirmed = false,
IsReceived = false,
OrderReferenceId = Guid.NewGuid().ToString(),
TotalPrice = 0,
PaymentType = PaymentTypeEnum.CREDIT,
DeliveryType = DeliveryTypeEnum.DELIVERY,
CreatedAt = DateTimeOffset.UtcNow,
UpdatedAt = DateTimeOffset.UtcNow
};
HGContext.Orders.Add(cartEntity);
var addcartresult = await HGContext.SaveChangesAsync();
if (addcartresult == 0)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, model));
}
}
// Add check to make sure product is in stock
var variant = await HGContext.DispensaryProductVariants.FirstOrDefaultAsync(x => x.Id == model.VariantId && x.IsDeleted == false);
if (variant == null)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, "Product is no longer available."));
//return BadRequest("Product is no longer available.");
}
var addedToCart = false;
if (cartEntity.DispensaryProductVariantOrders.Count > 0)
{
//Search through existing products in cart to see if product and packaging (weight/units) already exists
foreach (var vo in cartEntity.DispensaryProductVariantOrders)
{
if (vo.DispensaryProductVariantId == model.VariantId)
{
//Same Variant and Packaging -- Increase Quantity
if (vo.VariantPriceId == model.VariantPriceId)
{
vo.Quantity++;
vo.TotalPrice = vo.Quantity * vo.UnitPrice;
vo.UpdatedAt = DateTimeOffset.UtcNow;
addedToCart = true;
break;
}
}
}
}
//if wasn't found above add to cart
if (!addedToCart)
{
var variantpricing = JsonConvert.DeserializeObject <List <VariantPricing> >(variant.VariantPricing);
var variantToAdd = new DispensaryProductVariantOrder()
{
Order = cartEntity,
IsPricedByWeight = variant.IsPricedByWeight,
Weight = variantpricing[model.VariantPriceId].Weight,
UnitPrice = variantpricing[model.VariantPriceId].Price,
Quantity = 1,
TotalPrice = variantpricing[model.VariantPriceId].Price,
DispensaryProductVariantId = model.VariantId,
VariantPriceId = model.VariantPriceId,
CreatedAt = DateTimeOffset.UtcNow,
UpdatedAt = DateTimeOffset.UtcNow
};
HGContext.DispensaryProductVariantOrders.Add(variantToAdd);
}
cartEntity.UpdatedAt = DateTimeOffset.UtcNow;
var result = await HGContext.SaveChangesAsync();
if (result > 0)
{
return(Request.CreateResponse(HttpStatusCode.OK));
}
else
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, "Unable to add product to cart"));
//return BadRequest("Unable to add product to cart");
}
}