public IDictionary <string, string> GetUserDataConsistencyErrors(AdvancedAdCreateModel model, IDictionary <string, string> errors)
{
if (String.IsNullOrEmpty(model.Name))
{
errors.Add("Name", "Veuillez saisir un nom.");
}
if (String.IsNullOrEmpty(model.Email))
{
errors.Add("Email", "Veuillez insérer une adresse email.");
}
else
if (!_emailRegex.IsMatch(model.Email))
{
errors.Add("Email", "Email invalide.");
}
if (String.IsNullOrEmpty(model.Password))
{
errors.Add("Password", "Veuillez saisir votre mot de passe.");
}
else
{
if (String.IsNullOrEmpty(model.PasswordConfirm))
{
errors.Add("PasswordConfirm", "Veuillez confirmer le mot de passe.");
}
else
if (!model.Password.Equals(model.PasswordConfirm))
{
errors.Add("PasswordConfirm", "Les mots de passe saisis sont différents.");
}
}
return(errors);
}
public IDictionary <string, string> GetBaseAdDataConsistencyErrors(AdvancedAdCreateModel model, IDictionary <string, string> errors)
{
if (String.IsNullOrEmpty(model.Title))
{
errors.Add("Title", "Veuillez donner un titre à votre annonce.");
}
if (String.IsNullOrEmpty(model.Body))
{
errors.Add("Body", "Veuillez rédiger un texte d'annonce.");
}
if (model.Price < 0)
{
errors.Add("Price", "Veuillez saisir un prix positif.");
}
if (!String.IsNullOrEmpty(model.Telephone) && !_phoneRegex.IsMatch(model.Telephone))
{
errors.Add("Telephone", "Telephone invalide.");
}
if (model.SelectedCityId == null)
{
errors.Add("SelectedCityId", "Veuillez sélectionner une ville.");
}
if (model.SelectedCategoryId == null)
{
errors.Add("SelectedCategoryId", "Veuillez séléctionner une catégorie.");
}
return(errors);
}
public IDictionary <string, string> GetCarAdDataConsistencyErrors(AdvancedAdCreateModel model, IDictionary <string, string> errors)
{
if (model.Km == null)
{
errors.Add("Km", "Veuillez séléctionner un kilométrage.");
}
else
if (model.Km.Value < 0)
{
errors.Add("Km", "Kilométrage incorrecte.");
}
if (model.SelectedFuelId == null)
{
errors.Add("SelectedFuelId", "Veuillez sélectionner un type.");
}
if (model.SelectedCarBrandId == null)
{
errors.Add("SelectedCarBrandId", "Veuillez sélectionner une marque.");
}
if (model.SelectedYearId == null)
{
errors.Add("SelectedYearId", "Veuillez sélectionner une annee-modele.");
}
return(errors);
}
public IDictionary <string, string> GetMotoAdDataConsistencyErrors(AdvancedAdCreateModel model, IDictionary <string, string> errors)
{
if (model.Km == null)
{
errors.Add("Km", "Veuillez séléctionner un kilométrage.");
}
else
if (model.Km.Value < 0)
{
errors.Add("Km", "Kilométrage incorrecte.");
}
if (model.SelectedYearId == null)
{
errors.Add("SelectedYearId", "Veuillez sélectionner une annee-modele.");
}
if (model.EngineSize == null)
{
errors.Add("EngineSize", "Veuillez sélectionner une cylindrée.");
}
else
if (model.EngineSize.Value < 0)
{
errors.Add("EngineSize", "Cylindrée incorrecte.");
}
if (model.SelectedMotoBrandId == null)
{
errors.Add("SelectedMotoBrandId", "Veuillez sélectionner une marque.");
}
return(errors);
}
public IDictionary <string, string> GetAdDataConsistencyErrors(AdvancedAdCreateModel model)
{
IDictionary <string, string> errors = new Dictionary <string, string>();
// Check base ad data consistency
GetBaseAdDataConsistencyErrors(model, errors);
// Check user data consistency
GetUserDataConsistencyErrors(model, errors);
if (model.Type == AdTypeEnum.Undefined)
{
return(errors);
}
// Check specifyc ad data consistency
switch (model.Type)
{
case AdTypeEnum.CarAd:
GetCarAdDataConsistencyErrors(model, errors);
break;
case AdTypeEnum.MotoAd:
GetMotoAdDataConsistencyErrors(model, errors);
break;
case AdTypeEnum.OtherVehiculeAd:
GetOtherVehicleAdDataConsistencyErrors(model, errors);
break;
case AdTypeEnum.VehiculeAd:
GetVehicleAdDataConsistencyErrors(model, errors);
break;
case AdTypeEnum.MotorBoatAd:
GetMotorBoatAdDataConsistencyErrors(model, errors);
break;
case AdTypeEnum.SailingBoatAd:
GetSailingBoatAdDataConsistencyErrors(model, errors);
break;
case AdTypeEnum.MotorBoatEngineAd:
GetMotorBoatEngineAdDataConsistencyErrors(model, errors);
break;
case AdTypeEnum.WaterSportAd:
GetWaterSportAdDataConsistencyErrors(model, errors);
break;
case AdTypeEnum.RealEstateAd:
GetRealEstateAdDataConsistencyErrors(model, errors);
break;
default:
break;
}
return(errors);
}
public IDictionary <string, string> GetSailingBoatAdDataConsistencyErrors(AdvancedAdCreateModel model, IDictionary <string, string> errors)
{
if (model.SelectedHullTypeId == null)
{
errors.Add("SelectedHullTypeId", "Veuillez sélectionner une coque.");
}
if (model.SelectedSailingBoatTypeId == null)
{
errors.Add("SelectedSailingBoatTypeId", "Veuillez sélectionner un matériaux.");
}
if (model.SelectedYearId == null)
{
errors.Add("SelectedYearId", "Veuillez sélectionner une annee-modele.");
}
if (model.Length == null)
{
errors.Add("Length", "Veuillez saisir une longueur.");
}
else
if (model.Length.Value < 0)
{
errors.Add("Length", "Longueur incorrecte.");
}
return(errors);
}
public IDictionary <string, string> GetRealEstateAdDataConsistencyErrors(AdvancedAdCreateModel model, IDictionary <string, string> errors)
{
if (model.SelectedRealEstateTypeId == null)
{
errors.Add("SelectedRealEstateTypeId", "Veuillez sélectionner un type de bien.");
}
if (model.RoomNb == null)
{
errors.Add("RoomNb", "Veuillez sélectionner un nombre de pieces.");
}
else
if (model.RoomNb.Value < 0)
{
errors.Add("RoomNb", "Nombre de pieces incorrecte.");
}
if (model.SurfaceArea == null)
{
errors.Add("SurfaceArea", "Veuillez saisir une superficie.");
}
else
if (model.SurfaceArea.Value < 0)
{
errors.Add("SurfaceArea", "Superficie incorrecte.");
}
if (model.IsFurnished == null)
{
errors.Add("IsFurnished", "Veuillez selectionner une option.");
}
return(errors);
}
public IDictionary <string, string> GetWaterSportAdDataConsistencyErrors(AdvancedAdCreateModel model, IDictionary <string, string> errors)
{
if (model.SelectedWaterSportTypeId == null)
{
errors.Add("SelectedWaterSportTypeId", "Veuillez sélectionner une discipline.");
}
return(errors);
}
public BaseAd GetAdFromAdCreateModel(AdvancedAdCreateModel model)
{
BaseAd baseAd = null;
Category selectedCategory = null;
//Should not happened, category is mandatory
if (!model.SelectedCategoryId.HasValue)
{
return(baseAd);
}
else
{
selectedCategory = _repository.Get <Category>(model.SelectedCategoryId);
}
switch (selectedCategory.Type)
{
case AdTypeEnum.Ad:
baseAd = GetAdFromCreateModel <Ad>(baseAd, model);
break;
case AdTypeEnum.CarAd:
baseAd = GetAdFromCreateModel <CarAd>(baseAd, model);
break;
case AdTypeEnum.RealEstateAd:
baseAd = GetAdFromCreateModel <RealEstateAd>(baseAd, model);
break;
case AdTypeEnum.MotoAd:
baseAd = GetAdFromCreateModel <MotoAd>(baseAd, model);
break;
case AdTypeEnum.OtherVehiculeAd:
baseAd = GetAdFromCreateModel <OtherVehicleAd>(baseAd, model);
break;
case AdTypeEnum.VehiculeAd:
baseAd = GetAdFromCreateModel <VehicleAd>(baseAd, model);
break;
case AdTypeEnum.MotorBoatAd:
baseAd = GetAdFromCreateModel <MotorBoatAd>(baseAd, model);
break;
case AdTypeEnum.MotorBoatEngineAd:
baseAd = GetAdFromCreateModel <MotorBoatEngineAd>(baseAd, model);
break;
case AdTypeEnum.SailingBoatAd:
baseAd = GetAdFromCreateModel <SailingBoatAd>(baseAd, model);
break;
}
return(baseAd);
}
public PartialViewResult AddParamters(int categoryId)
{
Category selectedCategory = _categoryServices.GetCategoryById(categoryId);
FillViewLists(selectedCategory.Type);
AdvancedAdCreateModel model = new AdvancedAdCreateModel();
switch (selectedCategory.Type)
{
case AdTypeEnum.CarAd:
model.Type = AdTypeEnum.CarAd;
return(PartialView("Shared/Create/_CarAdCreate", model));
case AdTypeEnum.MotoAd:
model.Type = AdTypeEnum.MotoAd;
return(PartialView("Shared/Create/_MotoAdCreate", model));
case AdTypeEnum.VehiculeAd:
model.Type = AdTypeEnum.VehiculeAd;
return(PartialView("Shared/Create/_VehicleAdCreate", model));
case AdTypeEnum.OtherVehiculeAd:
model.Type = AdTypeEnum.OtherVehiculeAd;
return(PartialView("Shared/Create/_OtherVehicleAdCreate", model));
case AdTypeEnum.MotorBoatAd:
model.Type = AdTypeEnum.MotorBoatAd;
return(PartialView("Shared/Create/_MotorBoatAdCreate", model));
case AdTypeEnum.SailingBoatAd:
model.Type = AdTypeEnum.SailingBoatAd;
return(PartialView("Shared/Create/_SailingBoatAdCreate", model));
case AdTypeEnum.MotorBoatEngineAd:
model.Type = AdTypeEnum.MotorBoatEngineAd;
return(PartialView("Shared/Create/_MotorBoatEngineAdCreate", model));
case AdTypeEnum.WaterSportAd:
model.Type = AdTypeEnum.WaterSportAd;
return(PartialView("Shared/Create/_WaterSportAdCreate", model));
case AdTypeEnum.RealEstateAd:
model.Type = AdTypeEnum.RealEstateAd;
return(PartialView("Shared/Create/_realEstateAdCreate", model));
}
return(null);
}
public ActionResult Create(AdvancedAdCreateModel model)
{
IDictionary <string, string> errors = _adConsistencyServices.GetAdDataConsistencyErrors(model);
foreach (string key in errors.Keys)
{
ModelState.AddModelError(key, errors[key]);
}
// This line validates the captcha code and creates a ModelError if not valid
this.IsCaptchaValid("Code invalide");
if (ModelState.IsValid)
{
BaseAd newAd = _adServices.GetAdFromAdCreateModel(model);
_adServices.AddAd(newAd);
return(View("Created"));
}
FillViewLists(model.Type);
return(View(model));
}
public IDictionary <string, string> GetMotorBoatAdDataConsistencyErrors(AdvancedAdCreateModel model, IDictionary <string, string> errors)
{
if (model.SelectedMotorTypeId == null)
{
errors.Add("SelectedMotorTypeId", "Veuillez sélectionner un type de moteur.");
}
if (model.SelectedMotorBoatTypeId == null)
{
errors.Add("SelectedMotorBoatTypeId", "Veuillez sélectionner un type.");
}
if (model.SelectedYearId == null)
{
errors.Add("SelectedYearId", "Veuillez sélectionner une annee-modele.");
}
if (model.Hp == null)
{
errors.Add("Hp", "Veuillez saisir une puissance.");
}
else
if (model.Hp.Value < 0)
{
errors.Add("Hp", "Puissance incorrecte.");
}
if (model.Length == null)
{
errors.Add("Length", "Veuillez saisir une longueur.");
}
else
if (model.Length.Value < 0)
{
errors.Add("Length", "Longueur incorrecte.");
}
return(errors);
}
public ActionResult Create()
{
AdvancedAdCreateModel model = new AdvancedAdCreateModel();
return(View(model));
}
private T GetAdFromCreateModel <T>(BaseAd baseAd, AdvancedAdCreateModel model) where T : BaseAd, new()
{
dynamic ad = new T();
//Common data
if (model.SelectedCityId.HasValue)
{
ad.City = _repository.Get <City>(model.SelectedCityId.Value);
}
if (model.SelectedCategoryId.HasValue)
{
ad.Category = _repository.Get <Category>(model.SelectedCategoryId.Value);
}
ad.Body = model.Body;
ad.CreationDate = DateTime.Now;
ad.Price = model.Price.GetValueOrDefault();
ad.Title = model.Title;
ad.IsOffer = model.IsOffer;
ad.PhoneNumber = model.Telephone;
ad.ActivationToken = _adActivationServices.GenerateActivationToken();
User createdBy = new User();
createdBy.Firstname = model.Name;
createdBy.Email = model.Email;
createdBy.Password = model.Password;
ad.CreatedBy = createdBy;
GetAdPicturesFromModel(ad, model.ImageIds);
//Other Data
if (model.Km.HasValue)
{
ad.Kilometers = model.Km.Value;
}
if (model.SelectedYearId.HasValue)
{
ad.Year = model.SelectedYearId.Value;
}
if (model.IsAutomatic.HasValue)
{
ad.IsAutomatic = model.IsAutomatic.Value;
}
if (model.SelectedCarBrandId.HasValue)
{
ad.Brand = _repository.Get <VehicleBrand>(model.SelectedCarBrandId.Value);
}
if (model.SelectedFuelId.HasValue)
{
ad.Fuel = _repository.Get <CarFuel>(model.SelectedFuelId);
}
if (model.SelectedMotoBrandId.HasValue)
{
ad.Brand = _repository.Get <MotoBrand>(model.SelectedMotoBrandId.Value);
}
if (model.EngineSize.HasValue)
{
ad.EngineSize = model.EngineSize.Value;
}
if (model.RoomNb.HasValue)
{
ad.RoomsNumber = model.RoomNb.Value;
}
if (model.SelectedRealEstateTypeId.HasValue)
{
ad.Type = _repository.Get <RealEstateType>(model.SelectedRealEstateTypeId);
}
if (model.SurfaceArea.HasValue)
{
ad.SurfaceArea = model.SurfaceArea.Value;
}
if (model.IsFurnished.HasValue)
{
ad.IsFurnished = model.IsFurnished.Value;
}
if (model.SelectedDistrictId.HasValue)
{
ad.District = _repository.Get <District>(model.SelectedDistrictId.Value);
}
if (model.Length.HasValue)
{
ad.Length = model.Length.Value;
}
if (model.SelectedSailingBoatTypeId.HasValue)
{
ad.SailingBoatType = _repository.Get <SailingBoatType>(model.SelectedSailingBoatTypeId);
}
if (model.SelectedHullTypeId.HasValue)
{
ad.HullType = _repository.Get <SailingBoatHullType>(model.SelectedHullTypeId);
}
if (model.SelectedMotorBoatTypeId.HasValue)
{
ad.MotorBoatType = _repository.Get <MotorBoatType>(model.SelectedMotorBoatTypeId);
}
if (model.Hp.HasValue)
{
ad.Hp = model.Hp.Value;
}
if (model.SelectedMotorBoatEngineTypeId.HasValue)
{
ad.MotorType = _repository.Get <MotorBoatEngineType>(model.SelectedMotorBoatEngineTypeId);
}
return(ad);
}
