public override void ExecuteOnComplete(Order order)
{
var tzi = TimeZoneInfo.FindSystemTimeZoneById("Mountain Standard Time");
var today = DateTime.UtcNow.AddHours(tzi.GetUtcOffset(DateTime.Now).Hours);
var featuredDate = DateTime.Parse(
this.Item.ProductOption, null,
System.Globalization.DateTimeStyles.AssumeUniversal);
//make sure the featured day is scheduled to exactly midnight.
featuredDate = featuredDate.Date.AddHours(-tzi.GetUtcOffset(featuredDate.Date).Hours);
using(var context = new RentlerContext())
{
var building = context.Buildings.FirstOrDefault(b => b.BuildingId == order.BuildingId);
if(building == null)
throw new ArgumentNullException("Building");
context.FeaturedListings.Add(new FeaturedListing
{
BuildingId = building.BuildingId,
ScheduledDate = featuredDate,
Zip = building.Zip
});
context.SaveChanges();
}
}
public void AddFeatured(Building building, List<DateTime> days)
{
var tzi = TimeZoneInfo.FindSystemTimeZoneById("Mountain Standard Time");
var today = DateTime.UtcNow.AddHours(tzi.GetUtcOffset(DateTime.Now).Hours);
//make sure the featured days are scheduled to exactly midnight
//of the day they've been purchased.
for (int i = 0; i < days.Count; i++)
days[i] = days[i].Date.AddHours(-tzi.GetUtcOffset(days[i].Date).Hours);
using (var context = new RentlerContext())
{
foreach (var item in days)
{
context.FeaturedListings.Add(new FeaturedListing
{
BuildingId = building.BuildingId,
ScheduledDate = item,
Zip = building.Zip
});
}
context.SaveChanges();
}
}
public UserCreditCard CreateCreditCardForUser(UserCreditCard card)
{
card = manager.CreateCustomerCard(card);
if(card == null)
return null;
using(var context = new RentlerContext())
{
context.UserCreditCards.Add(card);
context.SaveChanges();
}
return card;
}
public override void ExecuteOnComplete(Order order)
{
using (var context = new RentlerContext())
{
// get local date, to timestamp when the building was prioritized (so we can turn it off after 30 days)
TimeZoneInfo mstTZ = TimeZoneInfo.FindSystemTimeZoneById("Mountain Standard Time");
DateTime dateLocal = TimeZoneInfo.ConvertTimeFromUtc(DateTime.UtcNow, mstTZ);
var building = context.Buildings.FirstOrDefault(b => b.BuildingId == order.BuildingId);
if (building == null)
throw new ArgumentNullException("Building");
building.HasPriority = true;
building.DatePrioritized = dateLocal;
context.SaveChanges();
}
}
/// <summary>
/// Updates the terms specific fields on Building
/// </summary>
/// <param name="username">owner of the building</param>
/// <param name="building">the building</param>
/// <returns>
/// Status with the updated building
/// </returns>
public Status<Building> UpdatePropertyTerms(string username, Building building)
{
if (string.IsNullOrWhiteSpace(username))
return Status.ValidationError<Building>(null, "username", "username is required");
if (building == null)
return Status.ValidationError<Building>(null, "building", "building is null");
using (RentlerContext context = new RentlerContext())
{
try
{
Building current = (from b in context.Buildings.Include("User")
where b.IsDeleted == false &&
b.BuildingId == building.BuildingId &&
b.User.Username == username
select b).SingleOrDefault();
if (current == null)
return Status.NotFound<Building>();
current.IsBackgroundCheckRequired = building.IsBackgroundCheckRequired;
current.IsCreditCheckRequired = building.IsCreditCheckRequired;
current.Price = building.Price;
current.Deposit = building.Deposit;
current.RefundableDeposit = building.RefundableDeposit;
current.DateAvailableUtc = building.DateAvailableUtc;
current.LeaseLengthCode = building.LeaseLengthCode;
current.IsSmokingAllowed = building.IsSmokingAllowed;
current.ArePetsAllowed = building.ArePetsAllowed;
// pets are not allowed so no fee can be charged
if (!building.ArePetsAllowed)
current.PetFee = decimal.Zero;
else
current.PetFee = building.PetFee;
// validate the building
var validation = Status.Validatate<Building>(current);
if (validation.StatusCode != 200)
return validation;
context.SaveChanges();
InvalidateCache(building.BuildingId);
return Status.OK<Building>(current);
}
catch (Exception ex)
{
// log exception
return Status.Error<Building>(
"An unexpected error occurred while trying to update rental terms. Contact Rentler support for assistance.",
building
);
}
}
}
/// <summary>
/// Updates the promotional specific fields on Building
/// </summary>
/// <param name="username">owner of the building</param>
/// <param name="building">the building</param>
/// <returns>
/// Status with the updated building
/// </returns>
public Status<Building> UpdatePropertyPromotions(string username, Building building,
string ribbonId, IEnumerable<DateTime> featuredDates, string priorityListing)
{
if (building == null)
return Status.ValidationError<Building>(null, "building", "building is null");
using (RentlerContext context = new RentlerContext())
{
try
{
Building current = (from b in context.Buildings
.Include("User")
.Include("TemporaryOrder")
where b.IsDeleted == false &&
b.BuildingId == building.BuildingId &&
b.User.Username == username
select b).SingleOrDefault();
if (current == null)
return Status.NotFound<Building>();
current.Title = building.Title;
current.Description = building.Description;
// validate the building
var validation = Status.Validatate<Building>(current);
if (validation.StatusCode != 200)
return validation;
// delete any old order
if (current.TemporaryOrder != null)
context.Orders.Remove(current.TemporaryOrder);
// add order with ribbon if items
if (!string.IsNullOrWhiteSpace(ribbonId) || featuredDates != null || !string.IsNullOrWhiteSpace(priorityListing))
{
Order order = new Order();
order.UserId = current.UserId;
order.BuildingId = current.BuildingId;
order.CreateDate = DateTime.UtcNow;
order.CreatedBy = "propertyAdapter";
order.OrderStatus = OrderStatus.New;
//calculate order total here
if (!string.IsNullOrWhiteSpace(ribbonId))
order.OrderTotal += Configuration.Products.GetProduct("ribbon")
.ToOrderItem(ribbonId, 1).Price;
if (featuredDates != null)
order.OrderTotal += Configuration.Products
.GetProduct("featureddate").ToOrderItem(
DateTime.UtcNow.ToString("G"), 1).Price * featuredDates.Count();
if (!string.IsNullOrWhiteSpace(priorityListing))
order.OrderTotal += Configuration.Products
.GetProduct("prioritylisting").ToOrderItem(
DateTime.UtcNow.ToString("G"), 1).Price;
context.Orders.Add(order);
context.SaveChanges();
current.TemporaryOrder = order;
current.TemporaryOrderId = order.OrderId;
// add ribbon
if (!string.IsNullOrWhiteSpace(ribbonId))
{
var ribbonItem = Configuration.Products.GetProduct("ribbon").ToOrderItem(ribbonId, 1);
ribbonItem.OrderId = order.OrderId;
context.OrderItems.Add(ribbonItem);
}
// add featured dates
if (featuredDates != null)
{
for (int i = 0; i < featuredDates.Count(); ++i)
{
// featured dates come through with no time, we we have to add it
DateTime date = featuredDates.ElementAt(i);
date = date.Add(DateTime.Now.TimeOfDay);
DateTime dateUtc = date.ToUniversalTime();
var featuredItem = Configuration.Products.GetProduct("featureddate").ToOrderItem(dateUtc.ToString("G"), 1);
featuredItem.OrderId = order.OrderId;
context.OrderItems.Add(featuredItem);
}
}
// add priority listing
if (!string.IsNullOrWhiteSpace(priorityListing))
{
var priorityItem =
Configuration.Products.GetProduct("prioritylisting")
.ToOrderItem(true.ToString(), 1);
priorityItem.OrderId = order.OrderId;
context.OrderItems.Add(priorityItem);
}
}
context.SaveChanges();
InvalidateCache(building.BuildingId);
return Status.OK<Building>(current);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
// log exception
return Status.Error<Building>(
"An unexpected error occurred while trying to save promotions. Contact Rentler support for assistance.",
building
);
}
}
}
/// <summary>
/// Gets the application for user. If the application doesn't
/// exist then one is created.
/// </summary>
/// <param name="username">The username of the user.</param>
/// <returns>
/// A user application.
/// </returns>
public Status<UserApplication> GetApplicationForUser(string username)
{
using (var context = new RentlerContext())
{
// get the user
User result = (from u in context.Users.Include("UserApplication")
where u.Username == username
select u).SingleOrDefault();
if (result == null)
return Status.NotFound<UserApplication>();
UserApplication application;
if (result.UserApplication == null)
{
application = new UserApplication();
application.UserId = result.UserId;
context.UserApplications.Add(application);
context.SaveChanges();
}
else
{
application = result.UserApplication;
}
return Status.OK<UserApplication>(application);
}
}
/// <summary>
/// Sets the application for user.
/// </summary>
/// <param name="username">The username of the user to set the application for.</param>
/// <param name="userApplication">The user's application.</param>
/// <returns>
/// The user application that was saved.
/// </returns>
public Status<UserApplication> SaveApplicationForUser(
string username, UserApplication userApplication)
{
var identity = CustomAuthentication.GetIdentity();
if (!identity.IsAuthenticated)
return Status.UnAuthorized<UserApplication>();
using (var context = new RentlerContext())
{
try
{
bool isNew = false;
var application = (from u in context.UserApplications
where u.UserId == identity.UserId
select u).SingleOrDefault();
if (application == null)
{
application = new UserApplication { UserId = identity.UserId };
isNew = true;
}
application.ConvictedExplaination = userApplication.ConvictedExplaination;
application.EmergencyContact = userApplication.EmergencyContact;
application.EmergencyContactAddressLine1 = userApplication.EmergencyContactAddressLine1;
application.EmergencyContactAddressLine2 = userApplication.EmergencyContactAddressLine2;
application.EmergencyContactCity = userApplication.EmergencyContactCity;
application.EmergencyContactPhone = userApplication.EmergencyContactPhone;
application.EmergencyContactState = userApplication.EmergencyContactState;
application.EmergencyContactZip = userApplication.EmergencyContactZip;
application.FirstName = userApplication.FirstName;
application.HasBeenConvicted = userApplication.HasBeenConvicted;
application.HasEverBeenUnlawfulDetainer = userApplication.HasEverBeenUnlawfulDetainer;
application.LastName = userApplication.LastName;
application.PresentAddressLine1 = userApplication.PresentAddressLine1;
application.PresentAddressLine2 = userApplication.PresentAddressLine2;
application.PresentCity = userApplication.PresentCity;
application.PresentEmployer = userApplication.PresentEmployer;
application.PresentEmployerPhone = userApplication.PresentEmployerPhone;
application.PresentLandlord = userApplication.PresentLandlord;
application.PresentLandlordPhone = userApplication.PresentLandlordPhone;
application.PresentPhone = userApplication.PresentPhone;
application.PresentState = userApplication.PresentState;
application.PresentZip = userApplication.PresentZip;
application.PreviousAddressLine1 = userApplication.PreviousAddressLine1;
application.PreviousAddressLine2 = userApplication.PreviousAddressLine2;
application.PreviousCity = userApplication.PreviousCity;
application.PreviousEmployer = userApplication.PreviousEmployer;
application.PreviousEmployerPhone = userApplication.PreviousEmployerPhone;
application.PreviousLandlord = userApplication.PreviousLandlord;
application.PreviousLandlordPhone = userApplication.PreviousLandlordPhone;
application.PreviousState = userApplication.PreviousState;
application.PreviousZip = userApplication.PreviousZip;
application.Ssn = userApplication.Ssn;
application.UpdateDateUtc = DateTime.UtcNow;
application.UpdatedBy = "accountadapter";
application.VehicleColor = userApplication.VehicleColor;
application.VehicleLicenseNumber = userApplication.VehicleLicenseNumber;
application.VehicleMake = userApplication.VehicleMake;
application.VehicleModel = userApplication.VehicleModel;
application.VehicleState = userApplication.VehicleState;
application.VehicleYear = userApplication.VehicleYear;
// new applications need to be added to the context
if (isNew)
context.UserApplications.Add(application);
context.SaveChanges();
return Status.OK<UserApplication>(application);
}
catch (Exception ex)
{
// TODO: log exception
return Status.Error<UserApplication>("System was unable to create/update application", null);
}
}
}
/// <summary>
/// Gets the property that includes all of the temporary ordering
/// information that is associated.
/// </summary>
/// <param name="buildingId">The building id.</param>
/// <param name="username">The username.</param>
/// <returns>
/// A building with all the temporary ordering information.
/// </returns>
public Status<Building> GetPropertyPromoteInfo(long buildingId, string username)
{
if (string.IsNullOrWhiteSpace(username))
return Status.ValidationError<Building>(null, "username", "The username is required");
using (var context = new RentlerContext(false))
{
try
{
var building = (from b in context.Buildings
.Include("TemporaryOrder.OrderItems")
where b.IsDeleted == false &&
b.BuildingId == buildingId &&
b.User.IsDeleted == false &&
b.User.Username == username
select b).SingleOrDefault();
// invalid building id
if (building == null)
return Status.NotFound<Building>();
// see if temporary order is still valid
if (building.TemporaryOrder != null)
{
bool hasChanges = false;
// we only care about featured date order items
var featuredOrderItems = building.TemporaryOrder.OrderItems.Where(i => i.ProductId == "featureddate");
if (featuredOrderItems != null)
{
for (int i = 0; i < featuredOrderItems.Count(); ++i)
{
var orderItem = featuredOrderItems.ElementAt(i);
// get date as is in db
DateTime featureUtc = DateTime.Parse(orderItem.ProductOption);
if (featureUtc.Date < DateTime.UtcNow.Date)
{
// if the featured date has passed its invalid so remove it
context.OrderItems.Remove(orderItem);
--i;
hasChanges = true;
}
}
}
if (building.TemporaryOrder.OrderItems.Count == 0)
{
context.Orders.Remove(building.TemporaryOrder);
// redundant but its here just in case we get a messed
// up temporary order with no order items
hasChanges = true;
}
if (hasChanges)
context.SaveChanges();
}
return Status.OK<Building>(building);
}
catch (Exception ex)
{
return Status.Error<Building>(ex.Message, null);
}
}
}
/// <summary>
/// Removed the requested building
/// </summary>
/// <param name="buildingId">building identifier</param>
/// <param name="username">owner of the building</param>
/// <returns>
/// status indicating whether building was successfully removed
/// </returns>
public Status<bool> DeleteBuilding(long buildingId, string username)
{
if (buildingId == 0)
return Status.ValidationError<bool>(false, "buildingId", "buildingId is required");
if (string.IsNullOrWhiteSpace(username))
return Status.ValidationError<bool>(false, "username", "username is required");
using (var context = new RentlerContext())
{
var building = (from b in context.Buildings.Include("User")
where b.IsDeleted == false &&
b.BuildingId == buildingId &&
b.User.Username == username
select b).SingleOrDefault();
if (building == null)
return Status.NotFound<bool>();
// soft delete building
building.IsDeleted = true;
try
{
context.SaveChanges();
InvalidateCache(building.BuildingId);
return Status.OK<bool>(true);
}
catch (Exception ex)
{
return Status.Error<bool>(
ex.Message,
false
);
}
}
}
/// <summary>
/// Creates the building.
/// </summary>
/// <param name="username">The username.</param>
/// <param name="building">The building.</param>
/// <returns></returns>
public Status<Building> CreateBuilding(string username, Building building)
{
// validate the input
if (string.IsNullOrWhiteSpace(username))
return Status.ValidationError<Building>(null, "username", "username is required");
if (building == null)
return Status.ValidationError<Building>(null, "building", "building is null");
// validate the building
var validation = Status.Validatate<Building>(building);
if (validation.StatusCode != 200)
return validation;
// normalize standard amenities
if (building.BuildingAmenities != null)
{
var amenities = building.BuildingAmenities.Distinct().ToList();
for (int x = 0; x < amenities.Count; ++x)
{
if (!Amenities.Current.IsValidAmenity(amenities[x].AmenityId))
{
amenities.RemoveAt(x);
--x;
}
}
building.BuildingAmenities = amenities;
}
// normalize custom amenities
if (building.CustomAmenities != null)
{
var custom = building.CustomAmenities.Distinct().ToList();
// pascal case custom amenities
for (int x = 0; x < custom.Count; ++x)
{
if (string.IsNullOrEmpty(custom[x].Name))
{
custom.RemoveAt(x);
--x;
continue;
}
custom[x].Name = char.ToUpper(custom[x].Name[0]) + custom[x].Name.Substring(1);
}
building.CustomAmenities = custom;
}
//get the lat/lng location of the building
Geocode(building);
// add it
using (RentlerContext context = new RentlerContext())
{
var user = (from u in context.Users.Include("ContactInfos")
where u.Username == username && !u.IsDeleted
select u).FirstOrDefault();
if (user == null)
return Status.ValidationError<Building>(null, "username", "User doesn't exist");
// try to make one
if (building.ContactInfo == null)
return Status.ValidationError<Building>(null, "contactinfo", "No contact information specified");
// validate the contactinfo
var contactValidation = Status.Validatate<ContactInfo>(building.ContactInfo);
if (contactValidation.StatusCode != 200)
return Status.ValidationError<Building>(null, "contactinfo", "The contact information is not valid");
// if the contactinfoid isn't set
if (building.ContactInfoId == 0)
{
// add it
ContactInfo finalContact = building.ContactInfo;
user.ContactInfos.Add(finalContact);
context.SaveChanges();
// add it to the building
building.ContactInfoId = finalContact.ContactInfoId;
}
else
{
var contact = user.ContactInfos.Where(u => u.ContactInfoId == building.ContactInfoId).FirstOrDefault();
if (contact == null)
return Status.ValidationError<Building>(null, "contactinfoid", "ContactInfoId is invalid");
// update the contact info
contact.CompanyName = building.ContactInfo.CompanyName;
contact.ContactInfoTypeCode = building.ContactInfo.ContactInfoTypeCode;
contact.Email = building.ContactInfo.Email;
contact.Name = building.ContactInfo.Name;
contact.PhoneNumber = building.ContactInfo.PhoneNumber;
contact.ShowEmailAddress = building.ContactInfo.ShowEmailAddress;
contact.ShowPhoneNumber = building.ContactInfo.ShowPhoneNumber;
}
// don't allow them to pass complex object. We handled it above.
building.ContactInfo = null;
// set defaults
building.CreateDateUtc = DateTime.UtcNow;
building.CreatedBy = "propertyadapter";
building.UpdateDateUtc = DateTime.UtcNow;
building.UpdatedBy = "propertyadapter";
user.Buildings.Add(building);
try
{
context.SaveChanges();
}
catch (Exception e)
{
// log exception
return Status.Error<Building>(
"An unexpected error occurred while trying to save the listing information. Contact Rentler support for assistance.",
building
);
}
return Status.OK<Building>(building);
}
}
public Status<bool> RemoveUserCreditCard(int userCreditCardId)
{
UserCreditCard card;
using (var context = new RentlerContext())
{
card = (from c in context.UserCreditCards
where c.UserCreditCardId == userCreditCardId
select c).FirstOrDefault();
if (card == null)
return Status.NotFound<bool>();
card.IsDeleted = true;
manager.UpdateCustomerCard(card);
context.SaveChanges();
return Status.OK(true);
}
}
public Status<Order> ProcessOrder(
string username, int orderId, UserCreditCard card, bool saveCard)
{
bool isNewCard = card.UserCreditCardId == 0;
if (isNewCard)
{
// we're adding the new card regardless but we don't know if its valid
// if the user requested to save it we will make it active after the payment
// is successful, otherwise it will remain inactive
card.IsDeleted = true;
var cardResult = AddUserCreditCard(username, card);
if (cardResult.StatusCode != 200)
{
var orderStatus = GetOrderForCheckout(username, orderId);
orderStatus.StatusCode = 500;
orderStatus.Errors = new ValidationResult[] {
new ValidationResult("An unexpected failure occurred: payment was not processed", new string[] { "Order" })
};
return orderStatus;
}
}
else
{
//get the card
var storedCard = GetUserCreditCard(username, card.UserCreditCardId);
if (storedCard == null)
{
var orderStatus = GetOrderForCheckout(username, orderId);
orderStatus.StatusCode = 500;
orderStatus.Errors = new ValidationResult[] {
new ValidationResult("Failed to locate credit card on file: payment was not processed", new string[] { "Order" })
};
return orderStatus;
}
//update the billing address if anything changed
if (storedCard.Address1 != card.Address1 ||
storedCard.Address2 != card.Address2 ||
storedCard.City != card.City ||
storedCard.FirstName != card.FirstName ||
storedCard.LastName != card.LastName ||
storedCard.State != card.State ||
storedCard.Zip != card.Zip)
{
storedCard.Address1 = card.Address1;
storedCard.Address2 = card.Address2;
storedCard.City = card.City;
storedCard.FirstName = card.FirstName;
storedCard.LastName = card.LastName;
storedCard.State = card.State;
storedCard.Zip = card.Zip;
var updateStatus = UpdateUserCreditCard(username, storedCard);
if (updateStatus.StatusCode != 200)
{
var orderStatus = GetOrderForCheckout(username, orderId);
orderStatus.StatusCode = 500;
orderStatus.Errors = new ValidationResult[] {
new ValidationResult("Failed to update card address: payment was not processed", new string[] { "Order" })
};
return orderStatus;
}
}
card = storedCard;
}
//grab the order
var order = GetOrderForCheckout(username, orderId);
//attach the credit card to the order for our records
order.Result.UserCreditCardId = card.UserCreditCardId;
if (order.StatusCode != 200)
return order;
//let's pay for stuff!
CardPaymentResult result;
if (App.StorePricing == "Penny")
result = manager.AuthorizeCreditCardPayment(card, 0.01m);
else
result = manager.AuthorizeCreditCardPayment(card, order.Result.OrderTotal);
//did it work?
if (result.Approved)
{
order.Result.OrderStatus = OrderStatus.Succeeded;
}
else
{
order.StatusCode = 500;
// the payment method used is not valid so it should not be attached to
// the order. Clear it here and the change will be persisted later
order.Result.UserCreditCardId = null;
//gateway might be down
if (result.ServiceUnavailable)
{
order.Result.OrderStatus = OrderStatus.ServiceUnavailable;
order.Errors = new ValidationResult[] {
new ValidationResult("Payment service is unavailable. Please try again later.", new string[] { "Order" })
};
}
//or it was declined
else
{
order.Result.OrderStatus = OrderStatus.CardDeclined;
order.Errors = new ValidationResult[] {
new ValidationResult("Credit Card was declined", new string[] { "Order" })
};
}
}
//update the order status
using (var context = new RentlerContext())
{
var toUpdate = (from o in context.Orders
.Include("Building")
where o.OrderId == order.Result.OrderId
select o).SingleOrDefault();
toUpdate.OrderStatus = order.Result.OrderStatus;
toUpdate.UserCreditCardId = order.Result.UserCreditCardId;
//remove temporary order if we're good
if (order.Result.OrderStatus == OrderStatus.Succeeded)
{
toUpdate.Building.TemporaryOrderId = null;
// allow credit card to be used again if requested
if (isNewCard && saveCard)
{
context.Entry(toUpdate).Reference(o => o.UserCreditCard).Load();
toUpdate.UserCreditCard.IsDeleted = false;
}
}
context.SaveChanges();
}
// send receipt only if order was successful
if (order.Result.OrderStatus == OrderStatus.Succeeded)
{
//send a receipt
EmailOrderReceiptModel model = new EmailOrderReceiptModel()
{
To = order.Result.User.Email,
Name = string.Format("{0} {1}", order.Result.User.FirstName, order.Result.User.LastName),
BuildingId = (order.Result.BuildingId.HasValue) ? order.Result.BuildingId.Value : 0,
OrderItems = order.Result.OrderItems.ToList(),
OrderTotal = order.Result.OrderTotal
};
mailer.Receipt(model);
}
return order;
}
public Status<bool> FulfillCompletedOrder(string username, int orderId)
{
using (var context = new RentlerContext())
{
var order = (from o in context.Orders
.Include("OrderItems")
.Include("Building")
where o.OrderId == orderId &&
(o.User.Username == username || o.User.Email == username)
select o).SingleOrDefault();
if (order == null)
Status.NotFound<bool>();
foreach (var item in order.OrderItems)
{
var p = Rentler.Configuration.Products
.GetProduct(item.ProductId)
.FromOrderItem(item);
p.ExecuteOnComplete(order);
}
context.SaveChanges();
return Status.OK(true);
}
}
/// <summary>
/// Updates the profile of the specified user
/// </summary>
/// <param name="username">the username of the user</param>
/// <param name="firstName">first name of user</param>
/// <param name="lastName">last name of user</param>
/// <param name="email">email of user</param>
/// <returns>
/// status result with this updated user
/// </returns>
public Status<User> UpdateProfile(string username, string firstName, string lastName, string email)
{
using (var context = new RentlerContext())
{
// get user to update
var userStatus = GetUser(username, context);
if (userStatus.StatusCode != 200)
return userStatus;
var user = userStatus.Result;
// email changed
if (user.Email.ToLower() != email.ToLower())
{
var dupEmail = context.Users
.Where(u => !u.IsDeleted && u.Email.ToLower() == email.ToLower())
.Count();
if (dupEmail > 0)
return Status.ValidationError<User>(null, "Email", "The email is already used");
// ok to update
user.Email = email;
}
user.FirstName = firstName;
user.LastName = lastName;
user.UpdatedBy = "AccountAdapter";
user.UpdateDateUtc = DateTime.UtcNow;
context.SaveChanges();
return Status<User>.OK(user);
}
}
public Status<UserInterest> SendApplication(string username, int userInterestId, UserApplication application)
{
if (string.IsNullOrWhiteSpace(username))
return Status.ValidationError<UserInterest>(null, "username", "The username is required");
// validate UserApplication
var appStatusValid = Status.Validatate<UserApplication>(application);
if (appStatusValid.StatusCode != 200)
return Status.ValidationError<UserInterest>(null, "application", "The application is not valid");
// update user application
var appStatusSave = SaveApplicationForUser(username, application);
if (appStatusSave.StatusCode != 200)
return Status.Error<UserInterest>("System was unable to update application", null);
using (RentlerContext context = new RentlerContext())
{
try
{
// get lead
var lead = (from i in context.UserInterests
where i.User.Username == username && i.UserInterestId == userInterestId
select i).SingleOrDefault();
if (lead == null)
return Status.NotFound<UserInterest>();
// update lead - ApplicationSubmitted = true
lead.ApplicationSubmitted = true;
context.SaveChanges();
EmailSendApplicationModel model = new EmailSendApplicationModel(lead);
mailer.SendApplication(model);
return Status.OK(lead);
}
catch (Exception ex)
{
// log exception
return Status.Error<UserInterest>("System was unable to get lead", null);
}
}
}
/// <summary>
/// Activates the building.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="building">The building.</param>
/// <returns></returns>
private Status<Building> ActivateBuilding(RentlerContext context, Building building)
{
if (building == null)
return Status.NotFound<Building>();
if (!building.Bedrooms.HasValue)
return Status.Error("Listing is not complete", building);
////confirm this is a valid listing
//var listing = new Listing(building);
//if (!listing.IsValidListing)
// return Status.Error("Listing is not complete", building);
// set active
building.IsActive = true;
// if date activated is already set, only reset to now if it is more than 14 days old
if (building.DateActivatedUtc.HasValue)
{
if (building.DateActivatedUtc <= DateTime.UtcNow.AddDays(-14))
building.DateActivatedUtc = DateTime.UtcNow;
}
else
building.DateActivatedUtc = DateTime.UtcNow;
try
{
context.SaveChanges();
InvalidateCache(building.BuildingId);
return Status.OK<Building>(building);
}
catch (Exception ex)
{
return Status.Error<Building>(ex.Message, building);
}
}
public Status<UserCreditCard> UpdateUserCreditCard(string username, UserCreditCard card)
{
if (string.IsNullOrWhiteSpace(username))
return Status.ValidationError<UserCreditCard>(null, "username", "The username is required");
if (card == null)
return Status.ValidationError<UserCreditCard>(null, "card", "card is null");
card = manager.UpdateCustomerCard(card);
if (card.UserCreditCardId == 0)
return AddUserCreditCard(username, card);
using (RentlerContext context = new RentlerContext())
{
try
{
var userCreditCard = (from uc in context.UserCreditCards
where uc.User.IsDeleted == false &&
uc.User.Username == username &&
uc.UserCreditCardId == card.UserCreditCardId
select uc).SingleOrDefault();
userCreditCard.Alias = card.Alias;
userCreditCard.AccountReference = card.AccountReference;
userCreditCard.CardName = card.CardName;
userCreditCard.CardNumber = card.CardNumber;
userCreditCard.ExpirationMonth = card.ExpirationMonth;
userCreditCard.ExpirationYear = card.ExpirationYear;
userCreditCard.Address1 = card.Address1;
userCreditCard.Address2 = card.Address2;
userCreditCard.City = card.City;
userCreditCard.Email = card.Email;
userCreditCard.FirstName = card.FirstName;
userCreditCard.LastName = card.LastName;
userCreditCard.Phone = card.Phone;
userCreditCard.State = card.State;
userCreditCard.Zip = card.Zip;
userCreditCard.IsDeleted = card.IsDeleted;
userCreditCard.UpdatedBy = "orderadapter";
userCreditCard.UpdateDate = DateTime.UtcNow;
context.SaveChanges();
return Status.OK<UserCreditCard>(card);
}
catch (Exception ex)
{
return Status.Error<UserCreditCard>(ex.Message, card);
}
}
}
/// <summary>
/// Deactivates the building.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="building">The building.</param>
/// <returns></returns>
private Status<Building> DeactivateBuilding(RentlerContext context, Building building)
{
if (building == null)
return Status.NotFound<Building>();
building.IsActive = false;
try
{
context.SaveChanges();
InvalidateCache(building.BuildingId);
return Status.OK<Building>(building);
}
catch (Exception ex)
{
return Status.Error<Building>(ex.Message, building);
}
}
public Status<UserCreditCard> AddUserCreditCard(string username, UserCreditCard card)
{
if (string.IsNullOrWhiteSpace(username))
return Status.ValidationError<UserCreditCard>(null, "username", "The username is required");
if (card == null)
return Status.ValidationError<UserCreditCard>(null, "card", "card is null");
card.CreatedBy = "orderadapter";
card.CreateDate = DateTime.UtcNow;
// validate the contactinfo
var cardValidation = Status.Validatate<UserCreditCard>(card);
if (cardValidation.StatusCode != 200)
return Status.ValidationError<UserCreditCard>(card, "", "credit card is not valid");
card.AccountReference = Guid.NewGuid();
card = manager.CreateCustomerCard(card);
if (card == null)
return Status.Error("Problem creating card on payment service.", card);
using (RentlerContext context = new RentlerContext())
{
try
{
var user = (from u in context.Users
where u.IsDeleted == false &&
u.Username == username
select u).SingleOrDefault();
user.UserCreditCards.Add(card);
context.SaveChanges();
return Status.OK<UserCreditCard>(card);
}
catch (Exception ex)
{
return Status.Error<UserCreditCard>(ex.Message, card);
}
}
}
public Status<Building> CreateProperty(Building building)
{
var identity = CustomAuthentication.GetIdentity();
if (!identity.IsAuthenticated)
return Status.UnAuthorized<Building>();
if (building == null)
return Status.ValidationError<Building>(null, "building", "building is null");
//get the lat/lng location of the building
Geocode(building);
using (RentlerContext context = new RentlerContext())
{
try
{
building.UserId = identity.UserId;
// set defaults
building.CreateDateUtc = DateTime.UtcNow;
building.CreatedBy = "propertyadapter.createproperty";
context.Buildings.Add(building);
context.SaveChanges();
return Status.OK<Building>(building);
}
catch (Exception ex)
{
// TODO: log exception
return Status.Error<Building>("An unexpected error occurred so the property was not created. Contact Rentler Support for assistance.", building);
}
}
}
/// <summary>
/// Registers the specified user.
/// </summary>
/// <param name="user">The user.</param>
/// <param name="password">The password.</param>
/// <returns></returns>
public Status<User> RegisterUser(User user, string password)
{
user.CreateDateUtc = DateTime.UtcNow;
user.UpdateDateUtc = DateTime.UtcNow;
user.UpdatedBy = "AccountAdapter";
// validate the object
var result = Status.Validatate<User>(user);
if (result.StatusCode != 200)
return result;
if (string.IsNullOrWhiteSpace(password))
return Status.ValidationError<User>(null, "Password", "The password was not specified");
using (var context = new RentlerContext())
{
try
{
// check for dup email
var dupEmail = context.Users.Where(u => !u.IsDeleted && u.Email.ToLower() == user.Email.ToLower()).Count();
if (dupEmail > 0)
{
return Status.ValidationError<User>(null, "Email", "The email is already used");
}
// check for dup username
var dupUser = context.Users.Where(u => !u.IsDeleted && u.Username.ToLower() == user.Username.ToLower()).Count();
if (dupUser > 0)
{
return Status.ValidationError<User>(null, "Username", "The username is already used");
}
user.PasswordHash = FormsAuthentication.HashPasswordForStoringInConfigFile(password, "SHA1");
// create the user
context.Users.Add(user);
context.SaveChanges();
// notify user by email that their password was changed successfully.
EmailAccountRegisterModel model = new EmailAccountRegisterModel()
{
Name = string.Format("{0} {1}", user.FirstName, user.LastName),
To = user.Email
};
mailer.Register(model);
return Status<User>.OK(user);
}
catch (Exception ex)
{
// TODO: log exception
return Status.Error<User>("System was unable to create user", null);
}
}
}
public Status<bool> DeleteUserInterest(string username, int userInterestId)
{
if (string.IsNullOrWhiteSpace(username))
return Status.ValidationError<bool>(false, "username", "The username is required");
using (RentlerContext context = new RentlerContext())
{
try
{
var lead = (from i in context.UserInterests
where i.Building.User.Username == username && i.UserInterestId == userInterestId
select i).SingleOrDefault();
if (lead == null)
return Status.NotFound<bool>();
context.UserInterests.Remove(lead);
context.SaveChanges();
return Status.OK(true);
}
catch (Exception ex)
{
// TODO: log exception
return Status.Error<bool>("System was unable to remove the lead", false);
}
}
}
/// <summary>
/// Takes care of storing the user's credit card information.
/// If it is a new card, it will create a new entry in the payment system
/// and in our own storage. If it is just an update (e.g. the user changing their
/// address information), it will act accordingly.
/// </summary>
/// <param name="card">The user's credit card.</param>
public void UpdateCreditCardForUser(UserCreditCard card)
{
card = manager.UpdateCustomerCard(card);
if(card.UserCreditCardId == 0)
CreateCreditCardForUser(card);
else
{
UserCreditCard toUpdate = null;
using(var context = new RentlerContext())
{
toUpdate = (from u in context.UserCreditCards
where u.UserId == card.UserId &&
u.UserCreditCardId == card.UserCreditCardId
select u).SingleOrDefault();
if(toUpdate == null)
throw new ArgumentNullException();
toUpdate.Alias = card.Alias;
toUpdate.AccountReference = card.AccountReference;
toUpdate.CardName = card.CardName;
toUpdate.CardNumber = card.CardNumber;
toUpdate.ExpirationMonth = card.ExpirationMonth;
toUpdate.ExpirationYear = card.ExpirationYear;
toUpdate.Address1 = card.Address1;
toUpdate.Address2 = card.Address2;
toUpdate.City = card.City;
toUpdate.Email = card.Email;
toUpdate.FirstName = card.FirstName;
toUpdate.LastName = card.LastName;
toUpdate.Phone = card.Phone;
toUpdate.State = card.State;
toUpdate.Zip = card.Zip;
toUpdate.IsDeleted = card.IsDeleted;
context.SaveChanges();
}
}
}
public Status<UserInterest> SendUserResponse(string username, int userInterestId, string response)
{
if (string.IsNullOrWhiteSpace(username))
return Status.ValidationError<UserInterest>(null, "username", "The username is required");
if (string.IsNullOrWhiteSpace(response))
return Status.ValidationError<UserInterest>(null, "response", "Response is required");
using (RentlerContext context = new RentlerContext())
{
try
{
var lead = (from i in context.UserInterests
where i.Building.User.Username == username && i.UserInterestId == userInterestId
select i).SingleOrDefault();
if (lead == null)
return Status.NotFound<UserInterest>();
lead.ResponseMessage = response;
context.SaveChanges();
EmailRequestApplicationModel model = new EmailRequestApplicationModel(lead);
this.mailer.RequestApplication(model);
return Status.OK(lead);
}
catch (Exception ex)
{
// log exception
return Status.Error<UserInterest>("System was unable to get lead", null);
}
}
}
/// <summary>
/// Resets the password of the specified user
/// </summary>
/// <param name="email">user's email</param>
/// <returns></returns>
public Status<User> ResetPassword(string email)
{
using (var context = new RentlerContext())
{
try
{
var user = (from u in context.Users
where !u.IsDeleted && u.Email == email
select u).FirstOrDefault();
if (user == null)
return Status.ValidationError<User>(null, "Email", "No user with this email exists");
// generate a random password 8 char long
string newPassword = FormsAuthentication
.HashPasswordForStoringInConfigFile(
DateTime.Now.ToString() + user.Username,
"SHA1")
.Substring(0, 8);
// hash the random password and update user with it
user.PasswordHash = FormsAuthentication
.HashPasswordForStoringInConfigFile(newPassword, "SHA1");
context.SaveChanges();
EmailForgotPasswordModel model = new EmailForgotPasswordModel()
{
To = user.Email,
Username = user.Username,
NewPassword = newPassword
};
mailer.ForgotPassword(model);
return Status.OK<User>(user);
}
catch (Exception ex)
{
// TODO: log exception
return Status.Error<User>("System was unable to reset password", null);
}
}
}
/// <summary>
/// Takes care of storing the user's bank account information.
/// If it is a new card, it will create a new entry in the payment system
/// and in our own storage. If it is just an update (e.g. the user changing their
/// address information), it will act accordingly.
/// </summary>
/// <param name="bank">The user's bank account.</param>
public void UpdateBankForUser(UserBank bank)
{
bank = manager.UpdateCustomerBank(bank);
if(bank.UserBankId == 0)
CreateBankForUser(bank);
else
{
using(var context = new RentlerContext())
{
var toUpdate = (from u in context.UserBanks
where u.UserId == bank.UserId &&
u.UserBankId == bank.UserBankId
select u).SingleOrDefault();
if(toUpdate == null)
throw new ArgumentNullException();
toUpdate.AccountName = bank.AccountName;
toUpdate.AccountNumber = bank.AccountNumber;
toUpdate.AccountType = bank.AccountType;
toUpdate.PayerAlias = bank.PayerAlias;
toUpdate.PayeeAlias = bank.PayeeAlias;
toUpdate.RoutingNumber = bank.RoutingNumber;
toUpdate.Address1 = bank.Address1;
toUpdate.Address2 = bank.Address2;
toUpdate.City = bank.City;
toUpdate.Email = bank.Email;
toUpdate.FirstName = bank.FirstName;
toUpdate.LastName = bank.LastName;
toUpdate.Phone = bank.Phone;
toUpdate.State = bank.State;
toUpdate.Zip = bank.Zip;
toUpdate.IsDeleted = bank.IsDeleted;
context.SaveChanges();
}
}
}
public Status<Building> UpdateProperty(Building building)
{
var identity = CustomAuthentication.GetIdentity();
if (!identity.IsAuthenticated)
return Status.UnAuthorized<Building>();
if (building == null)
return Status.ValidationError<Building>(null, "building", "building is null");
// address could have changed, if so we need to get new lat lon
Geocode(building);
using (RentlerContext context = new RentlerContext())
{
try
{
var presentBuilding = (from b in context.Buildings
where b.UserId == identity.UserId &&
b.BuildingId == building.BuildingId
select b).SingleOrDefault();
presentBuilding.PropertyTypeCode = building.PropertyTypeCode;
presentBuilding.Address1 = building.Address1;
presentBuilding.Address2 = building.Address2;
presentBuilding.City = building.City;
presentBuilding.State = building.State;
presentBuilding.Zip = building.Zip;
presentBuilding.Latitude = building.Latitude;
presentBuilding.Longitude = building.Longitude;
presentBuilding.UpdateDateUtc = DateTime.UtcNow;
presentBuilding.UpdatedBy = "propertyadapter.updateproperty";
context.SaveChanges();
InvalidateCache(presentBuilding.BuildingId);
return Status.OK<Building>(presentBuilding);
}
catch (Exception)
{
// log exception
return Status.Error<Building>("An unexpected error occurred so the requested property changes were not completed. Contact Rentler Support for assistance.", building);
}
}
}
/// <summary>
/// Updates the listing information specific fields on Building
/// </summary>
/// <param name="username">owner of the building</param>
/// <param name="building">the building</param>
/// <returns>
/// Status with the updated building
/// </returns>
public Status<Building> UpdatePropertyListingInfo(Listing building)
{
var identity = CustomAuthentication.GetIdentity();
if (!identity.IsAuthenticated)
return Status.UnAuthorized<Building>();
if (building == null)
return Status.ValidationError<Building>(null, "building", "building is null");
// normalize standard amenities
if (building.BuildingAmenities != null)
{
var amenities = building.BuildingAmenities.Distinct().ToList();
for (int x = 0; x < amenities.Count; ++x)
{
if (!Amenities.Current.IsValidAmenity(amenities[x].AmenityId))
{
amenities.RemoveAt(x);
--x;
}
}
building.BuildingAmenities = amenities;
}
// normalize custom amenities
if (building.CustomAmenities != null)
{
var custom = building.CustomAmenities.Distinct().ToList();
// pascal case custom amenities
for (int x = 0; x < custom.Count; ++x)
{
if (string.IsNullOrEmpty(custom[x].Name))
{
custom.RemoveAt(x);
--x;
continue;
}
custom[x].Name = char.ToUpper(custom[x].Name[0]) + custom[x].Name.Substring(1);
}
building.CustomAmenities = custom;
}
// update it
using (RentlerContext context = new RentlerContext())
{
try
{
var current = (from b in context.Buildings
.Include("BuildingAmenities")
.Include("CustomAmenities")
.Include("User.ContactInfos")
.Include("ContactInfo")
where b.IsDeleted == false &&
b.BuildingId == building.BuildingId &&
b.UserId == identity.UserId
select b).SingleOrDefault();
if (current == null)
return Status.NotFound<Building>();
// update properties
current.Acres = building.Acres;
current.SquareFeet = building.SquareFeet;
current.YearBuilt = building.YearBuilt;
current.Bedrooms = building.Bedrooms;
current.Bathrooms = building.Bathrooms;
if (building.BuildingAmenities != null)
{
// building amenities
foreach (var a in building.BuildingAmenities)
{
// has this amenity already been added?
if (!current.BuildingAmenities.Any(ba => ba.AmenityId == a.AmenityId))
current.BuildingAmenities.Add(a);
}
for (int i = 0; i < current.BuildingAmenities.Count; ++i)
{
// make sure each current amenity is still wanted
if (!building.BuildingAmenities.Any(ba => ba.AmenityId == current.BuildingAmenities.ElementAt(i).AmenityId))
{
current.BuildingAmenities.Remove(current.BuildingAmenities.ElementAt(i));
--i;
}
}
}
if (building.CustomAmenities != null)
{
// custom amenities
foreach (var a in building.CustomAmenities)
{
// has this amenity already been added?
if (!current.CustomAmenities.Any(ca => ca.Name == a.Name))
current.CustomAmenities.Add(a);
}
for (int i = 0; i < current.CustomAmenities.Count; ++i)
{
// make sure each current amenity is still wanted
if (!building.CustomAmenities.Any(ca => ca.Name == current.CustomAmenities.ElementAt(i).Name))
{
current.CustomAmenities.Remove(current.CustomAmenities.ElementAt(i));
--i;
}
}
}
// try to make one
if (building.ContactInfo == null)
return Status.ValidationError<Building>(null, "contactinfo", "No contact information specified");
// validate the contactinfo
var contactValidation = Status.Validatate<ContactInfo>(building.ContactInfo);
if (contactValidation.StatusCode != 200)
return Status.ValidationError<Building>(null, "contactinfo", "The contact information is not valid");
// if the contactinfoid isn't set
if (building.ContactInfo.ContactInfoId == 0)
{
// add it
ContactInfo finalContact = building.ContactInfo;
current.User.ContactInfos.Add(finalContact);
context.SaveChanges();
// add it to the building
current.ContactInfoId = finalContact.ContactInfoId;
}
else
{
var contact = current.User.ContactInfos.Where(u => u.ContactInfoId == building.ContactInfo.ContactInfoId).FirstOrDefault();
if (contact == null)
return Status.ValidationError<Building>(null, "contactinfoid", "ContactInfoId is invalid");
// update the contact info
contact.CompanyName = building.ContactInfo.CompanyName;
contact.ContactInfoTypeCode = building.ContactInfo.ContactInfoTypeCode;
contact.Email = building.ContactInfo.Email;
contact.Name = building.ContactInfo.Name;
contact.PhoneNumber = building.ContactInfo.PhoneNumber;
contact.ShowEmailAddress = building.ContactInfo.ShowEmailAddress;
contact.ShowPhoneNumber = building.ContactInfo.ShowPhoneNumber;
current.ContactInfoId = contact.ContactInfoId;
}
// set defaults
current.UpdateDateUtc = DateTime.UtcNow;
current.UpdatedBy = "propertyadapter.updatepropertylistinginfo";
//invalidate L2 cache
InvalidateCache(building.BuildingId);
context.SaveChanges();
return Status.OK<Building>(current);
}
catch (Exception e)
{
// TODO: log exception
return Status.Error<Building>(e.Message, null);
}
}
}
/// <summary>
/// Changes the password of the specified user
/// </summary>
/// <param name="username">the username of the user</param>
/// <param name="oldPassword">old password for user</param>
/// <param name="newPassword">new password for user</param>
/// <param name="confirmPassword">confirmed new password for user</param>
/// <returns></returns>
public Status<User> ChangePassword(string username, string oldPassword, string newPassword, string confirmPassword)
{
if (confirmPassword != newPassword)
return Status<User>.ValidationError<User>(null, "ConfirmPassword", "Passwords do not match");
using (var context = new RentlerContext())
{
// get user whose password needs to be reset
var userStatus = GetUser(username, context);
if (userStatus.StatusCode != 200)
return userStatus;
var user = userStatus.Result;
if (user.PasswordHash != FormsAuthentication.HashPasswordForStoringInConfigFile(oldPassword, "SHA1"))
return Status<User>.ValidationError<User>(null, "OldPassword", "Old Password is incorrect");
try
{
// reset password
user.PasswordHash = FormsAuthentication.HashPasswordForStoringInConfigFile(newPassword, "SHA1");
context.SaveChanges();
// notify user by email that their password was changed successfully.
EmailChangePasswordModel model = new EmailChangePasswordModel()
{
Name = string.Format("{0} {1}", user.FirstName, user.LastName),
To = user.Email
};
mailer.ChangePassword(model);
return Status<User>.OK(user);
}
catch (Exception ex)
{
// TODO: log exception
return Status.Error<User>("System was unable to change password", null);
}
}
}