public ActionResult AddEvent(AddEventModel viewModel)
{
var session = Session["Login"] as SessionModel;
if (session != null)
{
using (var db = new MechAppProjectEntities())
{
var serviceId = Convert.ToInt32(viewModel.WorkshopService.Value);
var service = db.WorkshopServices.First(x => x.ServiceId == serviceId);
var serviceStartTime = viewModel.ServiceHours.Value.Split(':');
var startDate = viewModel.ServiceDate + new TimeSpan(Convert.ToInt32(serviceStartTime[0]), Convert.ToInt32(serviceStartTime[1]), 0);
var endDate = startDate + new TimeSpan(service.DurationInHrs, service.DurationInMinutes, 0);
var serviceEventModel = new ServiceEvent()
{
CustomerId = session.UserId,
ServiceId = service.ServiceId,
OrderStatus = (int)OrderStatus.OrderReceived,
StartDate = startDate,
EndDate = endDate
};
db.ServiceEvents.Add(serviceEventModel);
db.SaveChanges();
}
}
return(RedirectToAction("Index", "Home"));
}
public JsonResult Add(AddEventModel model)
{
try
{
var component = GetComponentById(model.ComponentId);
var client = GetDispatcherClient();
var response = client.SendEvent(CurrentUser.AccountId, new SendEventData()
{
ComponentId = component.Id,
TypeSystemName = model.EventType,
TypeDisplayName = model.EventType,
Message = model.Message,
Importance = model.EventImportance,
JoinInterval = (model.JoinInterval != null ? model.JoinInterval.Value.TotalSeconds : (double?)null),
Category = EventCategory.ComponentEvent
});
response.Check();
return(GetSuccessJsonResponse());
}
catch (Exception exception)
{
MvcApplication.HandleException(exception);
return(GetErrorJsonResponse(exception));
}
}
protected void CreateEvent_Click(object sender, EventArgs e)
{
System.Globalization.CultureInfo customCulture = new System.Globalization.CultureInfo("tr-tr", true);
customCulture.DateTimeFormat.ShortDatePattern = "dd-MM-yyyy";
System.Threading.Thread.CurrentThread.CurrentCulture = customCulture;
System.Threading.Thread.CurrentThread.CurrentUICulture = customCulture;
var user = Session["user"] as UserBO;
var model = new AddEventModel()
{
PersonId = user.Id,
Name = eventName.Value as string,
Description = description.Value as string,
City = city.Value as string,
StartDate = Convert.ToDateTime(DateTime.Parse(startDate.Value as string).ToString("yyyy-MM-dd h:mm tt")),
Category = selectedCategoryId
};
var response = eventBal.AddEvent(model);
if (response != null && response.IsSuccess == true)
{
Page.ClientScript.RegisterStartupScript(GetType(), "Scripts", "<script>alert('" + response.Message + "');</script>");
ClearForm();
}
}
public (bool ValidationResult, string ValidationMessage) ValidateAddEvent(AddEventModel model)
{
if (string.IsNullOrWhiteSpace(model.Name))
{
return(false, ErrorDictionary.GetErrorMessage(16, _culture));
}
if (!Enum.IsDefined(typeof(EventStatus), model.Status))
{
return(false, ErrorDictionary.GetErrorMessage(13, _culture));
}
if (model.Types == null || !model.Types.Any())
{
return(false, ErrorDictionary.GetErrorMessage(36, _culture));
}
else
{
if (model.Types.Count != model.Types.Distinct().Count())
{
return(false, ErrorDictionary.GetErrorMessage(37, _culture));
}
if (model.Types.Count > 3)
{
return(false, ErrorDictionary.GetErrorMessage(35, _culture));
}
foreach (var type in model.Types)
{
if (!Enum.IsDefined(typeof(EventType), type))
{
return(false, ErrorDictionary.GetErrorMessage(14, _culture));
}
}
}
if (model.StartTime > model.EndTime)
{
return(false, ErrorDictionary.GetErrorMessage(42, _culture));
}
if (model.MinAge.HasValue && model.MaxAge.HasValue && model.MinAge > model.MaxAge)
{
return(false, ErrorDictionary.GetErrorMessage(15, _culture));
}
if (model.IsOnline.HasValue && !model.IsOnline.Value && !model.CityId.HasValue)
{
return(false, ErrorDictionary.GetErrorMessage(31, _culture));
}
if (model.IsOnline.HasValue && model.IsOnline.Value && model.CityId.HasValue)
{
return(false, ErrorDictionary.GetErrorMessage(32, _culture));
}
if (model.CityId.HasValue)
{
var cities = _cityLogic.GetCities().Result;
if (!cities.Any(x => x.CityId == model.CityId))
{
return(false, ErrorDictionary.GetErrorMessage(30, _culture));
}
}
return(true, string.Empty);
}
public async Task <ActionResult> Create(AddEventModel model)
{
var put = await _client.PutAsync("/api/Event", new StringContent(JsonConvert.SerializeObject(model), Encoding.UTF8, "application/json"));
var readAsStringAsync = await put.Content.ReadAsStringAsync();
var eventId = JsonConvert.DeserializeObject <Guid>(readAsStringAsync);
return(RedirectToAction("GenerateFixtures", "Event", new { eventId }));
}
public ActionResult Add(Guid componentId, string returnUrl)
{
var component = GetComponentById(componentId);
var model = new AddEventModel()
{
ComponentId = component.Id,
DisplayName = component.DisplayName,
EventImportance = EventImportance.Success,
ReturnUrl = returnUrl
};
return(View(model));
}
public async Task <ActionResult <AddEventResponse> > AddEvent(AddEventModel request)
{
var uid = new Guid(HttpContext.Request.Headers[AuthorizationHeaders.PersonUid].First());
var validationResult = _eventValidation.ValidateAddEvent(request);
if (!validationResult.ValidationResult)
{
return(BadRequest(validationResult.ValidationMessage));
}
var eventUid = await _eventLogic.AddEvent(request, uid);
return(new AddEventResponse {
EventUid = eventUid
});
}
public async Task <Guid> AddEvent(AddEventModel addEventModel, Guid personUid)
{
var eventUid = Guid.NewGuid();
var person = await _personRepository.GetPerson(personUid);
var entity = _mapper.Map <EventEntity>(addEventModel);
entity.EventUid = eventUid;
entity.AdministratorId = person.PersonId;
entity.Chat = new ChatEntity {
ChatUid = Guid.NewGuid(), IsGroupChat = true
};
entity.CreationTime = DateTime.UtcNow;
var imageList = new List <EventImageContentEntity>();
if (addEventModel.PrimaryImage != null && addEventModel.PrimaryImage.Any())
{
var eventImageContentUid = await _imageLogic.SaveImage(addEventModel.PrimaryImage);
imageList.Add(new EventImageContentEntity
{
EventImageContentUid = eventImageContentUid,
IsPrimary = true
});
}
if (addEventModel.Images != null)
{
foreach (var image in addEventModel.Images)
{
var eventImageContentUid = await _imageLogic.SaveImage(image);
imageList.Add(new EventImageContentEntity
{
EventImageContentUid = eventImageContentUid,
IsPrimary = false
});
}
}
entity.EventImageContentEntities = imageList;
await _eventRepository.CreateEvent(entity);
await AddParticipant(new EventParticipantModel { EventUid = eventUid, PersonUid = person.PersonUid, ParticipantStatus = ParticipantStatus.Active }, personUid);
return(eventUid);
}
public ResultModel AddEvent(AddEventModel model)
{
if (!string.IsNullOrEmpty(model.City) &&
!string.IsNullOrEmpty(model.Description) &&
!string.IsNullOrEmpty(model.Name) &&
!string.IsNullOrEmpty(model.StartDate.ToString()))
{
return(eventDal.AddEvent(model));
}
else
{
return(new ResultModel()
{
IsSuccess = false,
Message = "Do not leave empty spaces"
});
}
}
// GET: Events
public ActionResult AddEvent(int workshopId)
{
var session = Session["Login"] as SessionModel;
var viewModel = new AddEventModel();
if (session != null)
{
using (var db = new MechAppProjectEntities())
{
var serviceEvents = db.ServiceEvents.Where(x => x.WorkshopService.WorkshopId == workshopId).ToList();
viewModel.CalendarEventsJson = serviceEvents.Select(x => new CalendarEventJson()
{
startDate = x.StartDate, endDate = x.EndDate, summary = x.WorkshopService.Title
}).ToList();
var customerCars = db.Cars
.Where(x => x.CustomerId == session.UserId)
.Select(x => new SelectListItem()
{
Text = x.Model, Value = x.CarId.ToString()
})
.ToList();
var workshopServices = db.WorkshopServices
.Where(x => x.WorkshopId == workshopId)
.Select(x => new SelectListItem()
{
Text = x.Title, Value = x.ServiceId.ToString()
})
.ToList();
viewModel.CustomerCarsSelectList = new SelectList(customerCars, "Value", "Text");
viewModel.WorkshopServicesSelectList = new SelectList(workshopServices, "Value", "Text");
viewModel.ServiceHourSelectList = new SelectList(EventsHelper.GetHoursToSelect(6, 21, 15), "Value", "Text");
}
}
return(View(viewModel));
}
public ActionResult AddEvent(AddEventModel new_event)
{
ECalendar cal = null;
if (0 != new_event.calendarId && null != this._db)
{
cal = this._db.SingleOrDefault <ECalendar>(new_event.calendarId);
}
if (!ModelState.IsValid)
{
TempData["StatusNewEvent"] = "Invalid";
return(RedirectToAction("Index", new { id = cal.Id }));
//ViewData["calendar"] = cal;
//return PartialView("Index");
}
TempData["StatusNewEvent"] = "Valid";
CalendarEntry entry = new CalendarEntry()
{
allDay = new_event.allday,
calendarId = new_event.calendarId,
description = new_event.description,
title = new_event.title,
start = new_event.start,
locationId = new_event.selectedLocation
};
if (new_event.start > new_event.end)
{
entry.end = null;
}
else
{
entry.end = new_event.end;
}
this._db.Insert(entry);
return(RedirectToAction("Index", new { id = cal.Id }));
}
public ResultModel AddEvent(AddEventModel model)
{
ResultModel result = new ResultModel();
sqlCommand = new SqlCommand()
{
Connection = connectionHelper.connection,
CommandType = CommandType.StoredProcedure,
CommandText = "AddEventSP",
};
sqlCommand.Parameters.Add("@PersonId", SqlDbType.Int).Value = model.PersonId;
sqlCommand.Parameters.Add("@Name", SqlDbType.NVarChar).Value = model.Name;
sqlCommand.Parameters.Add("@City", SqlDbType.NVarChar).Value = model.City;
sqlCommand.Parameters.Add("@StartDate", SqlDbType.DateTime).Value = model.StartDate;
sqlCommand.Parameters.Add("@Description", SqlDbType.NVarChar).Value = model.Description;
sqlCommand.Parameters.Add("@CategoryId", SqlDbType.Int).Value = model.Category;
connectionHelper.connection.Open();
SqlDataReader sqlReader = sqlCommand.ExecuteReader();
if (sqlReader.HasRows)
{
if (sqlReader.Read())
{
result = new ResultModel()
{
IsSuccess = (bool)sqlReader["IsSuccess"],
Message = sqlReader["Message"] as string
};
}
}
connectionHelper.connection.Close();
return(result);
}
