public async Task <IActionResult> Edit(int id, [Bind("EventSponsorID,EventID,SponsorID,HostID,SponsorshipLevel,NumTicketsAllocated")] EventSponsor eventSponsor)
{
if (id != eventSponsor.EventSponsorID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(eventSponsor);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EventSponsorExists(eventSponsor.EventSponsorID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["EventID"] = new SelectList(_context.Events, "EventId", "Name", eventSponsor.EventID);
ViewData["HostID"] = new SelectList(_context.Guests, "GuestID", "EmailAddress", eventSponsor.HostID);
ViewData["SponsorID"] = new SelectList(_context.Sponsors, "SponsorID", "Name", eventSponsor.SponsorID);
return(View(eventSponsor));
}
public IActionResult DeleteEventSponsor([FromBody] EventSponsor eventSponsor)
{
BaseResult <EventModel> baseResult = new BaseResult <EventModel>();
bool isSuccess = false;
Event _event = _SEvent.GetById(eventSponsor.eventId);
int userId = Convert.ToInt32(HttpContext.User.Identity.Name);
if (_event.userId == userId)
{
if (_SEventSponsor.DeleteEventSponsor(eventSponsor.eventId, eventSponsor.sponsorId))
{
isSuccess = true;
}
else
{
baseResult.errMessage = "Sponsor Silme İşlemi Tamamlanamadı!";
}
}
else
{
baseResult.errMessage = "Kendinize Ait Olmayan Bir Etkinliğe Müdahale Edemezsiniz";
}
if (isSuccess)
{
return(Json(baseResult));
}
else
{
baseResult.statusCode = HttpStatusCode.NotFound;
return(new NotFoundObjectResult(baseResult));
}
}
public ServiceResult UpdateEventSponsor(EventSponsor sponsor)
{
var result = new ServiceResult();
try
{
if (ValidateSponsor(sponsor, result))
{
EventSponsor updateSponsor =
_repository.EventSponsors.Find(x => x.EventSponsorId == sponsor.EventSponsorId);
updateSponsor.SponsorName = sponsor.SponsorName;
updateSponsor.Description = sponsor.Description;
_repository.EventSponsors.Update(updateSponsor);
_repository.SaveChanges();
}
}
catch (Exception ex)
{
result.AddServiceError(Utilities.GetInnerMostException(ex));
}
return(result);
}
public HttpResponseMessage UpdateEventSponsor(EventSponsor updateRecord)
{
try
{
ServicePointManager.Expect100Continue = true;
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12 | SecurityProtocolType.Tls11;
if (updateRecord == null)
{
return(new HttpResponseMessage(HttpStatusCode.BadRequest));
}
// Update the EventSponsor record in the Azure SQL DB:
int eventSponsorResult = _eventSponsorWorker.UpdateCreate(updateRecord);
if (eventSponsorResult > 0)
{
return(new HttpResponseMessage(HttpStatusCode.OK));
}
// Existed already:
else if (eventSponsorResult == 0)
{
return(new HttpResponseMessage(HttpStatusCode.OK));
}
return(new HttpResponseMessage(HttpStatusCode.OK));
}
catch (Exception e)
{
return(new HttpResponseMessage(HttpStatusCode.BadRequest));
}
}
// POST: api/EventsSponsors
public HttpResponseMessage Post([FromBody] EventSponsor value)
{
try
{
using (var db = new DataBaseContext())
{
var anotherLink = db.EventsSponsors.SingleOrDefault(x => x.EventID == value.EventID &&
x.SponsorID == value.SponsorID);
if (anotherLink != null)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotAcceptable, "The link between event and sponsor already exists"));
}
db.EventsSponsors.Add(value);
db.SaveChanges();
var message = Request.CreateResponse(HttpStatusCode.Created, value);
message.Headers.Location = new Uri(Request.RequestUri + value.Id.ToString());
return(message);
}
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
// PUT: api/EventsSponsors/5
public HttpResponseMessage Put(int id, [FromBody] EventSponsor value)
{
try
{
using (var db = new DataBaseContext())
{
db.Configuration.LazyLoadingEnabled = false;
var eventSponsor = db.EventsSponsors.SingleOrDefault(x => x.Id == id);
if (eventSponsor == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "EventSponsor with id = " + id + " not found"));
}
var anotherLink = db.EventsSponsors.SingleOrDefault(x => x.EventID == value.EventID && x.SponsorID == value.SponsorID && x.Id != id);
if (anotherLink != null)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotAcceptable, "The link between event and sponsor already exists"));
}
eventSponsor.LinkToFacebook = value.LinkToFacebook;
eventSponsor.Sponsor = value.Sponsor;
eventSponsor.Event = value.Event;
db.SaveChanges();
return(Request.CreateResponse(HttpStatusCode.OK, eventSponsor));
}
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
public async Task <IActionResult> AddSponsor2Event(String[] guests)
{
String[] sponsorIds = Request.Form["sponsors[]"].ToArray();
String eventId = Request.Form["eventID"].ToString();
int EID = int.Parse(eventId);
if (sponsorIds.Length > 0)
{
foreach (String sponsor in sponsorIds)
{
int sponsorid = int.Parse(sponsor);
// Console.WriteLine(sponsorid);
EventSponsor es = new EventSponsor {
EventID = EID, SponsorID = sponsorid,
};
_context.Add(es);
}
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
else
{
return(Ok("You selected no sponsors."));
}
}
public ActionResult Ajax_AddLogo(IEnumerable <HttpPostedFileBase> logos, int masterEventId)
{
try
{
foreach (var logo in logos)
{
Image img = Image.FromStream(logo.InputStream, true, true);
Image thumbnail = Utilities.ResizeImage(img, new Size {
Height = DirtyGirlConfig.Settings.LogoHieght, Width = DirtyGirlConfig.Settings.LogoWidth
});
var fileName = string.Format("{0}.png", Path.GetFileNameWithoutExtension(logo.FileName));
var thumbnailName = string.Format("thumbnail_{0}.png", Path.GetFileNameWithoutExtension(logo.FileName));
var physicalPath = Path.Combine(Server.MapPath(DirtyGirlConfig.Settings.EventImageFolder), masterEventId.ToString(), "sponsors");
var relativeUrl = string.Format("{0}/{1}/{2}/", DirtyGirlConfig.Settings.EventImageFolder, masterEventId, "sponsors");
var standardUrl = string.Format("{0}{1}", relativeUrl, fileName);
var thumbnailUrl = string.Format("{0}{1}", relativeUrl, thumbnailName);
var standardPath = Path.Combine(physicalPath, fileName);
var thumnailPath = Path.Combine(physicalPath, thumbnailName);
if (!Directory.Exists(physicalPath))
{
Directory.CreateDirectory(physicalPath);
}
img.Save(standardPath, ImageFormat.Png);
thumbnail.Save(thumnailPath, ImageFormat.Png);
EventSponsor sponsor = new EventSponsor();
sponsor.SponsorName = "Enter Sponsorship Name";
sponsor.EventId = masterEventId;
sponsor.FileName = fileName;
sponsor.Url = standardUrl;
sponsor.thumbnailUrl = thumbnailUrl;
ServiceResult result = _eventService.CreateEventSponsor(sponsor);
if (result.Success)
{
return(Content(""));
}
}
}
catch (Exception ex)
{
Elmah.ErrorSignal.FromCurrentContext().Raise(ex);
return(Content(ex.Message));
}
return(Content("An Error Occured Uploading your logo."));
}
/// <summary author="Phillip Hansen" created="2019/04/03">
/// Deletes the event by taking the object as a whole, and passes only the ID
/// </summary>
/// <param name="purgeEvent"></param> the event to be purged
public void DeleteEventSponsor(EventSponsor purgeEventSpons)
{
try
{
_eventSponsorAccessor.deleteEventByID(purgeEventSpons.EventID, purgeEventSpons.SponsorID);
}
catch (Exception ex)
{
ExceptionLogManager.getInstance().LogException(ex);
throw ex;
}
}
/// <summary>
/// @Author: Phillip Hansen
///
/// Event Handler for deleting a selected record
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnDeleteEventSpons_Click(object sender, RoutedEventArgs e)
{
EventSponsor selectedRecord = (EventSponsor)dgEventSponsor.SelectedItem;
if (dgEventSponsor.SelectedIndex > -1)
{
_eventSponsManager.DeleteEventSponsor(selectedRecord);
}
else
{
MessageBox.Show("A record from the list must be selected!");
}
}
public async Task <IActionResult> Create([Bind("EventSponsorID,EventID,SponsorID,HostID,SponsorshipLevel,NumTicketsAllocated")] EventSponsor eventSponsor)
{
if (ModelState.IsValid)
{
_context.Add(eventSponsor);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["EventID"] = new SelectList(_context.Events, "EventId", "Name", eventSponsor.EventID);
ViewData["HostID"] = new SelectList(_context.Guests, "GuestID", "EmailAddress", eventSponsor.HostID);
ViewData["SponsorID"] = new SelectList(_context.Sponsors, "SponsorID", "Name", eventSponsor.SponsorID);
return(View(eventSponsor));
}
public ServiceResult CreateEventSponsor(EventSponsor sponsor)
{
var result = new ServiceResult();
try
{
if (ValidateSponsor(sponsor, result))
{
_repository.EventSponsors.Create(sponsor);
_repository.SaveChanges();
}
}
catch (Exception ex)
{
result.AddServiceError(Utilities.GetInnerMostException(ex));
}
return(result);
}
public ServiceResult RemoveEventSponsor(int sponsorId)
{
var result = new ServiceResult();
try
{
EventSponsor sponsorToDelete = _repository.EventSponsors.Find(x => x.EventSponsorId == sponsorId);
if (CanRemoveSponsor(sponsorToDelete, result))
{
_repository.EventSponsors.Delete(sponsorToDelete);
_repository.SaveChanges();
}
}
catch (Exception ex)
{
result.AddServiceError(Utilities.GetInnerMostException(ex));
}
return(result);
}
public async Task <bool> AddSponsor(int eventId, EventSponsorInsertRequest request)
{
var entity = new EventSponsor
{
EventID = eventId,
SponsorID = request.SponsorID,
SponsorCategory = request.SponsorCategory
};
try
{
await _context.EventSponsors.AddAsync(entity);
await _context.SaveChangesAsync();
return(true);
}
catch
{
return(false);
}
}
public ActionResult Ajax_UpdateEventSponsor([DataSourceRequest] DataSourceRequest request, EventSponsor sponsor)
{
if (ModelState.IsValid)
{
ServiceResult result = _eventService.UpdateEventSponsor(sponsor);
if (!result.Success)
{
Utilities.AddModelStateErrors(this.ModelState, result.GetServiceErrors());
}
}
return(Json(ModelState.ToDataSourceResult()));
}
public ActionResult Ajax_DeleteEventSponsor([DataSourceRequest] DataSourceRequest request, EventSponsor sponsor)
{
ServiceResult result = _eventService.RemoveEventSponsor(sponsor.EventSponsorId);
if (result.Success)
{
var physicalPath = Path.Combine(Server.MapPath(DirtyGirlConfig.Settings.EventImageFolder), sponsor.EventId.ToString(), "sponsors");
FileInfo imageToDelete = new FileInfo(Path.Combine(physicalPath, sponsor.FileName));
FileInfo thumbnailToDelete = new FileInfo(Path.Combine(physicalPath, "thumbnail_" + sponsor.FileName));
try
{
imageToDelete.Delete();
thumbnailToDelete.Delete();
}
catch (Exception ex)
{
Elmah.ErrorSignal.FromCurrentContext().Raise(ex);
}
}
else
{
Utilities.AddModelStateErrors(this.ModelState, result.GetServiceErrors());
}
return(Json(ModelState.ToDataSourceResult()));
}
public IDAEvent createNewEvent(int ID, string Name, int Week, EventType type, bool Danish, EventSponsor sponsor)
{
private bool ValidateSponsor(EventSponsor sponsorToValidate, ServiceResult result)
{
return(result.Success);
}
