public async Task <IActionResult> SendAnnouncement([FromBody] AnnouncementDTO model)
{
try
{
var userIds = (await _eventOperationRepo.Participants(model.EventId)).Select(u => u.UserId).ToList();
if (userIds.IsNullOrEmpty())
{
return(NotFound("Kayıt bulunamadı."));
}
foreach (var id in userIds)
{
var playerIds = (await _userDeviceRepo.Where(d => d.UserId == id && d.IsLoggedin))
.Select(t => t.DeviceId)
.ToList();
_oneSignal.SendNotification(playerIds, model.Message);
}
return(Ok("Duyuru gönderilmiştir."));
}
catch (Exception ex)
{
_logHelper.Log("DashboardController", 500, "SendAnnouncement", ex.Message);
return(null);
}
}
public async Task <ActionResult <Announcement> > Post(AnnouncementDTO announcementDTO)
{
try
{
//раскоментировать для проверки капчи, при наличии годного клиента
// var captchaResponse = await _recaptcha.Validate(Request.Form);
//if (!captchaResponse.Success)
//{
// ModelState.AddModelError("reCaptchaError", "reCAPTCHA error occured. Please try again.");
// return RedirectToAction(nameof(Index));
//}
if (announcementDTO == null)
{
return(BadRequest());
}
Announcement announcement = _mapper.Map <AnnouncementDTO, Announcement>(announcementDTO);
announcement.OrderNumber = db.Announcements.Max(e => e.OrderNumber) + 1;
announcement.CreationDate = DateTime.Now;
db.Announcements.Add(announcement);
await db.SaveChangesAsync();
var query = db.Announcements.Where(an => an.Id == announcement.Id);
var announcementDTO2 = await _mapper.ProjectTo <AnnouncementDTO>(query).FirstOrDefaultAsync();
return(Ok(announcementDTO2));
}
catch (Exception e)
{
return(BadRequest(new { e.Message, e.StackTrace }));
}
}
public ActionResult CreateAnnouncement(AnnouncementCreateDTO announcementDTO, int id)
{
try
{
ApplicationUser user = _userRepository.GetUserBy(User.Identity.Name);
if (user is null || !user.Type.Equals(UserType.STAFF))
{
return(Unauthorized());
}
Passenger receiver = null;
if (announcementDTO.PassengerId != null)
{
receiver = (Passenger)_userRepository.GetUserById((int)announcementDTO.PassengerId);
}
Announcement announcement = new Announcement
{
Title = announcementDTO.Title,
Content = announcementDTO.Content,
Sender = (Staff)user,
Receiver = receiver
};
_flightRepository.CreateAnnouncement(id, announcement);
_flightRepository.SaveChanges();
return(Created("", AnnouncementDTO.FromAnnouncement(announcement)));
}
catch (Exception e) { return(BadRequest(e.Message)); }
}
public async Task <AnnouncementDTO> UpdateEntity(AnnouncementDTO announcementDTO)
{
Announcement updatedAnnouncement = _mapper.Map <Announcement>(announcementDTO);
await _repository.UpdateAsync(announcementDTO.Id, updatedAnnouncement);
await _hubContext.Clients.All.SendAsync(ChatHubEnum.announcementUpdated.ToString(), announcementDTO);
return(announcementDTO);
}
static async Task <Uri> CreateProductAsync(AnnouncementDTO obj)
{
HttpResponseMessage response = await client.PostAsJsonAsync("api/Announcement", obj);
response.EnsureSuccessStatusCode();
// Return the URI of the created resource.
return(response.Headers.Location);
}
public ActionResult Index()
{
var AnnouncementData = new AnnouncementDTO()
{
AnnouncementList = db.Announcements.OrderByDescending(x => x.Date).Take(50).ToList()
};
return(View(AnnouncementData));
}
public ActionResult Edit(int id)
{
var dataAnno = new AnnouncementDTO()
{
AnnouncementList = db.Announcements.ToList(),
AnnouncementData = db.Announcements.FirstOrDefault(x => x.Id == id)
};
return(View("Index", dataAnno));
}
static async Task <AnnouncementDTO> GetProductAsync(string path)
{
AnnouncementDTO product = null;
HttpResponseMessage response = await client.GetAsync(path);
if (response.IsSuccessStatusCode)
{
product = await response.Content.ReadAsAsync <AnnouncementDTO>();
}
return(product);
}
// PUT: api/Announcement/5
public HttpResponseMessage Put(long id, [FromBody] AnnouncementDTO value)
{
try
{
AnnouncementDTO found = Service.GetAnnouncement(id);
found = value;
Service.SaveAnnouncement(found);
return(Request.CreateResponse(HttpStatusCode.OK));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ex.Message));
}
}
public async Task <IActionResult> CreateEntity([FromBody] AnnouncementDTO announcementDTO)
{
try
{
AnnouncementDTO createdAnnouncement = await _announcementService.CreateEntity(announcementDTO);
return(Ok(createdAnnouncement));
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return(BadRequest(e.Message));
}
}
public async Task <IActionResult> GetEntityById(int announcementId)
{
try
{
AnnouncementDTO announcement = await _announcementService.GetEntityById(announcementId);
return(Ok(announcement));
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return(BadRequest(e.Message));
}
}
public async Task <AnnouncementDTO> CreateEntity(AnnouncementDTO announcementDTO)
{
Announcement announcement = _mapper.Map <Announcement>(announcementDTO);
announcement.Id = 0;
var dateToday = DateTime.Now;
announcement.CreationDate = dateToday.ToString("yyyy-MM-dd HH:mm:ss");
var createdAnnouncement = await _repository.CreateAsync(announcement);
var createdAnnouncementDto = _mapper.Map <AnnouncementDTO>(createdAnnouncement);
await _hubContext.Clients.All.SendAsync(ChatHubEnum.announcementCreated.ToString(), createdAnnouncementDto);
return(createdAnnouncementDto);
}
public HttpResponseMessage Post([FromBody] AnnouncementDTO value)
{
try
{
Service.SaveAnnouncement(value);
var response = Request.CreateResponse <AnnouncementDTO>(HttpStatusCode.Created, value);
string uri = Url.Link("DefaultApi", new { id = value.Id });
response.Headers.Location = new Uri(uri);
return(response);
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ex.Message));
}
}
public async Task <IActionResult> UpdateEntity([FromBody] AnnouncementDTO announcementDTO, int announcementId)
{
try
{
if (announcementDTO.Id != announcementId)
{
throw new InvalidOperationException("Passed model id is not equal to request URL id.");
}
await _announcementService.UpdateEntity(announcementDTO);
return(Ok(announcementDTO));
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return(BadRequest(e.Message));
}
}
static async Task RunAsync()
{
// New code:
client.BaseAddress = new Uri("http://localhost/App/");
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
try
{
// Create a new product
AnnouncementDTO obj = new AnnouncementDTO
{
Id = 1,
Title = "Evening service",
Type = AnnouncementType.WEEKLY.ToString(),
EventTime = new DateTime(2017, 5, 6),
UpdatedDate = new DateTime(2017, 5, 6),
UpdatedBy = "user",
Sermon = "John 1:1",
Hymns = "How Great is our God",
Host = new UserDTO {
FirstName = "Newton", LastName = "Acho", Phone = "1234567890",
Email = "emailAddress", UpdatedBy = "user", UpdatedDate = new DateTime(2017, 5, 6), Id = 1
},
};
var url = await CreateProductAsync(obj);
Console.WriteLine($"Created at {url}");
// Get the product
obj = await GetProductAsync(url.PathAndQuery);
// Get the updated product
obj = await GetProductAsync(url.PathAndQuery);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
Console.ReadLine();
}
public void UpdateEntityTest()
{
var announcementService = new Mock <IAnnouncementService>();
announcementService.Setup(mock => mock.UpdateEntity(It.IsAny <AnnouncementDTO>()));
var announcementController = new AnnouncementController(announcementService.Object);
var tempAnnouncementDTO = new AnnouncementDTO
{
Id = 1,
Title = "",
CreationDate = "",
Message = "",
};
announcementController.UpdateEntity(tempAnnouncementDTO, tempAnnouncementDTO.Id);
announcementService.Verify(mock => mock.UpdateEntity(It.IsAny <AnnouncementDTO>()), Times.Once);
}
// DELETE: api/Announcement/5
public HttpResponseMessage Delete(long id)
{
try
{
AnnouncementDTO toDelete = Service.GetAnnouncement(id);
if (toDelete != null)
{
Service.DeleteAnnouncement(toDelete);
return(Request.CreateResponse(HttpStatusCode.OK));
}
else
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, "Could not find Record to delete"));
}
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ex.Message));
}
}
public async Task <ActionResult <Announcement> > Put(AnnouncementDTO announcementDTO)
{
if (announcementDTO == null)
{
return(BadRequest());
}
Announcement announcement = _mapper.Map <AnnouncementDTO, Announcement>(announcementDTO);
if (!db.Announcements.Any(an => an.Id == announcement.Id))
{
return(NotFound());
}
db.Update(announcement);
await db.SaveChangesAsync();
var query = db.Announcements.Where(an => an.Id == announcement.Id);
var announcementDTO2 = await _mapper.ProjectTo <AnnouncementDTO>(query).FirstOrDefaultAsync();
return(Ok(announcementDTO2));
}
public ActionResult Index(AnnouncementDTO anno)
{
if (anno.AnnouncementData.Id == 0)
{
db.Announcements.Add(new Announcement
{
Date = DateTime.Now,
EntireContent = anno.AnnouncementData.EntireContent,
Title = anno.AnnouncementData.Title
});
db.SaveChanges();
}
else
{
var dataAnno = db.Announcements.FirstOrDefault(a => a.Id == anno.AnnouncementData.Id);
dataAnno.Title = anno.AnnouncementData.Title;
dataAnno.Date = anno.AnnouncementData.Date;
dataAnno.EntireContent = anno.AnnouncementData.EntireContent;
db.SaveChanges();
}
return(RedirectToAction("Index"));
}
public virtual void SaveAnnouncement(AnnouncementDTO announcement)
{
_repository.InsertAnnouncement(announcement);
}
public virtual void UpdateAnnouncement(AnnouncementDTO announcement)
{
_repository.Update(announcement);
}
public virtual void DeleteAnnouncement(AnnouncementDTO announcement)
{
_repository.DeleteById(announcement.Id);
}