public static EventMetadataVm CreateViewModel(EventMetadataRecord record, LoadMode mode,
IStorageProvider storageProvider)
{
if (record == null)
{
throw new ArgumentNullException("record");
}
var result = new EventMetadataVm {
Id = record.Id
};
if (mode == LoadMode.Compact || mode == LoadMode.Full)
{
result.Title = record.Title;
result.StartDate = record.StartTime;
result.EndDate = record.EndTime;
result.Picture = FileUtil.GetPictureUrl(record.Picture, storageProvider);
}
if (mode == LoadMode.Full)
{
result.CombineType = (CombineType)record.CombineType;
result.VenueOrderType = (VenueOrderType)record.VenueOrderType;
result.VenueTitleFormatType = (VenueTitleFormatType)record.VenueTitleFormatType;
result.Latitude = record.Latitude;
result.Longitude = record.Longitude;
result.Status = (EventStatus)record.Status;
result.Description = record.Description;
}
return(result);
}
public static string DisplayNumber(this EntityVm venue, EventMetadataVm eventMeta)
{
var number = eventMeta.VenueTitleFormatType == VenueTitleFormatType.NameAndNumber
? eventMeta.Venues.IndexOf(venue) + 1
: (int?)null;
var result = number.HasValue ? string.Format("{0}. ", number) : string.Empty;
return(result);
}
public ActionResult SaveEvent(EventMetadataVm eventVm)
{
var errors = _validator.ValidateEvent(eventVm);
if (errors.Count > 0)
{
HttpContext.Response.StatusCode = (int)HttpStatusCode.BadRequest;
return(Json(new ErrorResultVm(errors)));
}
var result = _eventService.SaveEvent(eventVm);
return(Json(result));
}
public static void UpdateByViewModel(EventMetadataRecord record, EventMetadataVm eventVm, EntityRecord host)
{
if (!eventVm.StartDate.HasValue)
{
throw new ArgumentNullException("eventVm.StartDate");
}
record.DateModified = DateTime.UtcNow;
record.EntityRecord = host;
record.Title = eventVm.Title.TrimIt().StripTags();
record.Description = eventVm.Description.TrimIt().StripTags();
record.StartTime = eventVm.StartDate.Value;
record.EndTime = eventVm.EndDate;
record.CombineType = (byte)eventVm.CombineType;
record.Status = (byte)eventVm.Status;
record.VenueOrderType = (byte)eventVm.VenueOrderType;
record.VenueTitleFormatType = (byte)eventVm.VenueTitleFormatType;
}
public static void UpdateByViewModelPicture(EventMetadataRecord record, EventMetadataVm eventVm,
Dictionary <ShowRecord, ShowVm> shows, IStorageProvider storageProvider)
{
var previousPictureUrl = FileUtil.GetPictureUrl(record.Picture, storageProvider);
if (previousPictureUrl != eventVm.Picture)
{
record.Picture = FileUtil.ProcessUploadedPicture(record.Picture, eventVm.Picture,
Path.Combine("event", record.Id.ToString(CultureInfo.InvariantCulture)),
storageProvider);
}
foreach (var showRec in record.ShowRecords
.Where(s => !s.IsReference && !s.IsDeleted)
.ToArray())
{
ShowVm showVm;
if (shows.TryGetValue(showRec, out showVm))
{
UpdateByViewModelPicture(record, showRec, showVm, storageProvider);
}
}
}
private void ResizePicture(EventMetadataVm eventMetaVm, PictureSize size)
{
FileUtil.ResizePicture(eventMetaVm, size, _imageProfileManager, Logger);
FileUtil.ResizePicture(eventMetaVm.Host, size, _imageProfileManager, Logger);
if (eventMetaVm.Venues == null)
{
return;
}
foreach (var venueVm in eventMetaVm.Venues)
{
FileUtil.ResizePicture(venueVm, PictureSize.Small, _imageProfileManager, Logger);
if (venueVm.Shows == null)
{
continue;
}
foreach (var showVm in venueVm.Shows)
{
FileUtil.ResizePicture(showVm, PictureSize.Small, _imageProfileManager, Logger);
}
}
}
public EventMetadataVm SaveEvent(EventMetadataVm eventVm)
{
if (eventVm == null)
{
throw new ArgumentNullException("eventVm");
}
if (eventVm.StartDate == null)
{
throw new ArgumentNullException("eventVm.StartDate");
}
var host = _entityRepository.Get(eventVm.Host.Id);
if (host == null)
{
throw new ArgumentOutOfRangeException("eventVm.Host");
}
if (!Services.Authorizer.Authorize(Permissions.UseAllContent) &&
host.SmartWalkUserRecord.Id != CurrentUserRecord.Id)
{
throw new ArgumentOutOfRangeException("eventVm.Host", "Can't add host created by other user to the event.");
}
var eventMeta = _eventMetadataRepository.Get(eventVm.Id) ?? new EventMetadataRecord
{
SmartWalkUserRecord = CurrentUserRecord,
DateCreated = DateTime.UtcNow
};
var access = eventMeta.GetAccess(Services.Authorizer, CurrentUserRecord);
if (access != AccessType.AllowEdit)
{
throw new SecurityException("Can't edit event.");
}
if (eventMeta.IsDeleted)
{
throw new InvalidOperationException("Can't edit deleted event.");
}
if (eventMeta.Status == (byte)EventStatus.Public &&
!Services.Authorizer.Authorize(Permissions.CreatePublicContent))
{
throw new SecurityException("Current user can not make public events.");
}
ViewModelFactory.UpdateByViewModel(eventMeta, eventVm, host);
var venues = CompressVenues(eventVm.Venues);
var showsDict = new Dictionary <ShowRecord, ShowVm>();
foreach (var venueVm in venues)
{
var venue = _entityRepository.Get(venueVm.Id);
if (venue == null)
{
continue;
}
SaveVenueDetail(eventMeta, venue, venueVm);
foreach (var showVm in venueVm.Shows)
{
// ReSharper disable once AccessToForEachVariableInClosure
var show = showVm.Id > 0
? eventMeta.ShowRecords.FirstOrDefault(s => s.Id == showVm.Id)
: null;
if (show == null && !venueVm.Destroy)
{
show = new ShowRecord
{
EventMetadataRecord = eventMeta,
EntityRecord = venue,
DateCreated = DateTime.UtcNow
};
eventMeta.ShowRecords.Add(show);
}
// if parent venue is deleted, all shows are deleted too
if (show != null && venueVm.Destroy)
{
showVm.Destroy = true;
}
if (show != null)
{
show.EntityRecord = venue; // in case if shows moved to another venue
ViewModelFactory.UpdateByViewModel(show, showVm);
if (!show.IsDeleted)
{
showsDict.Add(show, showVm);
}
}
}
UpdateReferenceShow(eventMeta, venue,
!venueVm.Destroy && venueVm.Shows.Count(s => !s.Destroy) == 0);
}
DestroyMissingVenues(eventMeta, venues);
RecalcEventCoordinates(eventMeta);
if (eventMeta.Id == 0)
{
_eventMetadataRepository.Create(eventMeta);
}
// handling uploaded pictures after event got an Id
ViewModelFactory.UpdateByViewModelPicture(eventMeta, eventVm, showsDict, _storageProvider);
_eventMetadataRepository.Flush();
var result = CreateViewModelContract(eventMeta, null);
return(result);
}
public static string DisplayName(this EventMetadataVm eventMeta)
{
return(eventMeta.Title ?? (eventMeta.Host != null ? eventMeta.Host.Name : null));
}
public static string DisplayPicture(this EventMetadataVm eventMeta)
{
return(eventMeta.Picture ?? (eventMeta.Host != null ? eventMeta.Host.Picture : null));
}
public static IList <AddressVm> Addresses(this EventMetadataVm eventMeta)
{
return(eventMeta.Venues == null ? null : eventMeta.Venues.SelectMany(v => v.Addresses).ToList());
}
public static string DisplayDate(this EventMetadataVm eventMeta, CultureInfo culture)
{
return(eventMeta.StartDate.ToString("D", culture) +
(eventMeta.EndDate.HasValue ? " - " + eventMeta.EndDate.ToString("D", culture) : string.Empty));
}
public static bool IsMultiDay(this EventMetadataVm eventMetadata)
{
return(DateTimeExtensions.IsMultiDay(eventMetadata.StartDate, eventMetadata.EndDate));
}
// TODO: To validate if there are duplicated venues
public IList <ValidationError> ValidateEvent(EventMetadataVm model)
{
var result = new List <ValidationError>();
var titleProperty = model.GetPropertyName(p => p.Title);
if (!string.IsNullOrEmpty(model.Title))
{
if (model.Title.Length > 255)
{
result.Add(new ValidationError(
titleProperty,
T("Title can not be longer than 255 characters.").Text));
}
}
var startDateProperty = model.GetPropertyName(p => p.StartDate);
if (!model.StartDate.HasValue)
{
result.Add(new ValidationError(
startDateProperty,
T("Start date can not be empty.").Text));
}
if (model.StartDate.HasValue && model.EndDate.HasValue &&
model.StartDate.Value > model.EndDate.Value)
{
result.Add(new ValidationError(
startDateProperty,
T("Start date has to be less than or equal to the end date.").Text));
}
var pictureProperty = model.GetPropertyName(p => p.Picture);
if (!string.IsNullOrEmpty(model.Picture))
{
if (model.Picture.Length > 255)
{
result.Add(new ValidationError(
pictureProperty,
T("Picture URL can not be longer than 255 characters.").Text));
}
}
var descriptionProperty = model.GetPropertyName(p => p.Description);
if (!string.IsNullOrEmpty(model.Description))
{
if (model.Description.Length > 3000)
{
result.Add(new ValidationError(
descriptionProperty,
T("Description can not be longer than 3000 characters.").Text));
}
}
if (model.Host == null)
{
result.Add(new ValidationError(
model.GetPropertyName(p => p.Host),
T("Event organizer can not be empty.").Text));
}
var venuesProperty = model.GetPropertyName(p => p.Venues);
var showsProperty = Reflection <EntityVm> .GetProperty(p => p.Shows).Name;
var venues = model.Venues != null
? model.Venues.Where(v => !v.Destroy).ToArray()
: new EntityVm[]
{
};
if (model.Status == EventStatus.Public && venues.Length < 1)
{
result.Add(new ValidationError(
venuesProperty,
T("At least one venue is required for public events.").Text));
}
for (var i = 0; i < venues.Length; i++)
{
var venueVm = venues[i];
if (venueVm.Id <= 0)
{
result.Add(new ValidationError(
string.Format("{0}[{1}]", venuesProperty, i + 1),
T("The venue should be selected.").Text));
}
if (venueVm.EventDetail != null &&
venueVm.EventDetail.Description != null &&
venueVm.EventDetail.Description.Length > 3000)
{
result.Add(new ValidationError(
string.Format("{0}[{1}]", venuesProperty, i + 1),
T("Venue description can not be longer than 3000 characters.").Text));
}
var shows = venueVm.Shows != null
? venueVm.Shows.Where(v => !v.Destroy).ToArray()
: new ShowVm[]
{
};
for (var j = 0; j < shows.Length; j++)
{
var showVm = shows[j];
result.AddRange(ValidateShow(
showVm,
model,
string.Format(
"{0}[{1}].{2}[{3}].",
venuesProperty,
i + 1,
showsProperty,
j + 1)));
}
}
return(result);
}
private IEnumerable <ValidationError> ValidateShow(ShowVm model, EventMetadataVm eventVm, string prefix = "")
{
var result = new List <ValidationError>();
var titleProperty = model.GetPropertyName(p => p.Title);
if (string.IsNullOrEmpty(model.Title))
{
result.Add(new ValidationError(
prefix + titleProperty,
T("Title can not be empty!").Text));
}
else if (model.Title.Length > 255)
{
result.Add(new ValidationError(
prefix + titleProperty,
T("Title can not be larger than 255 characters!").Text));
}
var pictureProperty = model.GetPropertyName(p => p.Picture);
if (!string.IsNullOrEmpty(model.Picture))
{
if (model.Picture.Length > 255)
{
result.Add(new ValidationError(
prefix + pictureProperty,
T("Picture url can not be larger than 255 characters!").Text));
}
else if (!model.Picture.IsUrlValid())
{
result.Add(new ValidationError(
prefix + pictureProperty,
T("Picture url is in bad format!").Text));
}
}
var detailsUrlProperty = model.GetPropertyName(p => p.DetailsUrl);
if (!string.IsNullOrEmpty(model.DetailsUrl))
{
if (model.DetailsUrl.Length > 255)
{
result.Add(new ValidationError(
prefix + detailsUrlProperty,
T("Details url can not be larger than 255 characters!").Text));
}
else if (!model.DetailsUrl.IsUrlValid())
{
result.Add(new ValidationError(
prefix + detailsUrlProperty,
T("Details url is in bad format!").Text));
}
}
var startTimeProperty = model.GetPropertyName(p => p.StartTime);
if (model.StartTime.HasValue && model.EndTime.HasValue &&
model.StartTime.Value > model.EndTime.Value)
{
result.Add(new ValidationError(
prefix + startTimeProperty,
T("Show start time has to be less than or equal to the end time.").Text));
}
var eventStartDate = eventVm.StartDate;
var eventEndDate = eventVm.EndDate ?? eventVm.StartDate;
if (model.StartTime.HasValue && eventStartDate.HasValue &&
(model.StartTime.Value < eventStartDate.Value.AddDays(-1) ||
(eventEndDate.HasValue && model.StartTime.Value > eventEndDate.Value.AddDays(1))))
{
result.Add(new ValidationError(
prefix + startTimeProperty,
T("Show start time has to be between event start and end dates.").Text));
}
var endTimeProperty = model.GetPropertyName(p => p.EndTime);
if (model.EndTime.HasValue && eventStartDate.HasValue &&
(model.EndTime.Value < eventStartDate.Value.AddDays(-1) ||
(eventEndDate.HasValue && model.EndTime.Value > eventEndDate.Value.AddDays(2))))
{
result.Add(new ValidationError(
prefix + endTimeProperty,
T("Show end time has to be between event start and end dates.").Text));
}
return(result);
}
