public async Task <List <Announcement> > GetAllForVipOwnerAsync(AnnouncementDto dto, CancellationToken token = default)
{
using (var db = new GuoGuoCommunityContext())
{
if (!Guid.TryParse(dto.OwnerCertificationId, out var ownerCertificationId))
{
throw new NotImplementedException("业主认证Id不正确！");
}
var ownerCertificationRecord = await db.OwnerCertificationRecords.Include(x => x.Industry.BuildingUnit.Building.SmallDistrict.Community.StreetOffice).Where(x => x.Id == ownerCertificationId && x.IsDeleted == false).FirstOrDefaultAsync(token);
if (ownerCertificationRecord == null)
{
throw new NotImplementedException("业主认证信息不存在！");
}
var list = await db.Announcements.Where(x => x.IsDeleted == false && x.DepartmentValue == dto.DepartmentValue).ToListAsync(token);
if (!string.IsNullOrWhiteSpace(dto.Title))
{
list = list.Where(x => x.Title.Contains(dto.Title)).ToList();
}
list = list.Where(x => x.SmallDistrictArray == ownerCertificationRecord.Industry.BuildingUnit.Building.SmallDistrictId.ToString()).ToList();
return(list);
}
}
public IActionResult GetAccouncementById(Guid id)
{
var announcement = GetAnnouncement(id);
var announcementDto = new AnnouncementDto(announcement);
return(Json(announcementDto));
}
public async Task <Announcement> AddAsync(AnnouncementDto dto, CancellationToken token = default)
{
using (var db = new GuoGuoCommunityContext())
{
var entity = db.Announcements.Add(new Announcement
{
Content = dto.Content,
SmallDistrictArray = dto.SmallDistrictArray,
DepartmentName = dto.DepartmentName,
DepartmentValue = dto.DepartmentValue,
Summary = dto.Summary,
Title = dto.Title,
CreateOperationTime = dto.OperationTime,
CreateOperationUserId = dto.OperationUserId,
LastOperationTime = dto.OperationTime,
LastOperationUserId = dto.OperationUserId,
CommunityId = dto.CommunityId,
CommunityName = dto.CommunityName,
SmallDistrictId = dto.SmallDistrictId,
SmallDistrictName = dto.SmallDistrictName,
StreetOfficeId = dto.StreetOfficeId,
StreetOfficeName = dto.StreetOfficeName
});
await db.SaveChangesAsync(token);
return(entity);
}
}
public async Task <IActionResult> CreateAnnouncement(AnnouncementDto announcement, IFormFile file)
{
try
{
await announcementService.CreateAnnouncementAsync(announcement, file).ConfigureAwait(false);
return(Ok(announcement));
}
catch (InvalidFileExtensionException ex)
{
log.Error($"Ocurrió un error al crear el comunicado: {ex.Message}");
return(StatusCode(HttpStatusCode.UnsupportedMediaType.GetHashCode(), ex.Message));
}
catch (InvalidFileSizeException ex)
{
log.Error($"Ocurrió un error al crear el comunicado: {ex.Message}");
return(StatusCode(HttpStatusCode.BadRequest.GetHashCode(), ex.Message));
}
catch (InvalidFileDimensionException ex)
{
log.Error($"Ocurrió un error al crear el comunicado: {ex.Message}");
return(StatusCode(HttpStatusCode.BadRequest.GetHashCode(), ex.Message));
}
catch (Exception ex)
{
log.Error($"Ocurrió un error al crear el comunicado: {ex.Message}");
return(StatusCode(HttpStatusCode.InternalServerError.GetHashCode(), ex.Message));
}
}
public async Task <IHttpActionResult> PutAnnouncement(int id, AnnouncementDto announcementDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != announcementDto.ID)
{
return(BadRequest());
}
var announcement = DtoToEntityIMapper.Map <AnnouncementDto, Announcement>(announcementDto); ////
UoW.GetRepository <Announcement>().ModifyEntityState(announcement);
try
{
await UoW.SaveAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AnnouncementExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task AddAnnouncementAsync(AnnouncementDto announcementDto)
{
var mapper = new MapperConfiguration(cfg => cfg.CreateMap <AnnouncementDto, AnnouncementEntity>()).CreateMapper();
var announcement = mapper.Map <AnnouncementDto, AnnouncementEntity>(announcementDto);
_unitOfWork.Repository <AnnouncementEntity>().Add(announcement);
await _unitOfWork.SaveChangesAsync();
}
public static void PushToUser(string who, AnnouncementDto message, PlanetHub hub)
{
IHubConnectionContext <dynamic> clients = GetClients(hub);
foreach (var connectionId in _connections.GetConnections(who))
{
clients.Client(connectionId).addChatMessage(message);
}
}
public void Init()
{
announcementRepository = Substitute.For <IAnnouncementRepository>();
var mapper = new MapperConfiguration(x => x.AddProfile(new MappingProfile())).CreateMapper();
log = Substitute.For <ILog>();
config = Substitute.For <IConfigProvider>();
blobStorageService = Substitute.For <IBlobStorageService>();
fileProcesingService = Substitute.For <IFileProcesingService>();
announcementService = new AnnouncementService(announcementRepository, blobStorageService, fileProcesingService, config, mapper, log);
file = Substitute.For <IFormFile>();
var content = "pruebaimagen";
var fileName = "test.png";
var memoryStreamFile = new MemoryStream();
var writer = new StreamWriter(memoryStreamFile);
writer.Write(content);
writer.Flush();
memoryStreamFile.Position = 0;
file.OpenReadStream().Returns(memoryStreamFile);
file.FileName.Returns(fileName);
announcementDto = new AnnouncementDto
{
IdAnnouncement = 0,
Description = "Auncio prueba",
DescriptionCallToAction = "",
ImageId = "",
Order = 0,
State = true,
ThumbnailImageId = "",
Title = "Auncio prueba",
UrlCallToAction = "",
UrlImage = "",
UrlThumbnailImage = ""
};
announcement = new Announcement
{
IdAnnouncement = 0,
Description = "Auncio prueba",
DescriptionCallToAction = "",
ImageId = "",
Order = 0,
State = true,
ThumbnailImageId = "",
Title = "Auncio prueba",
UrlCallToAction = "",
UrlImage = "",
UrlThumbnailImage = ""
};
}
public async Task <IHttpActionResult> PostAnnouncement(AnnouncementDto announcementDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var announcement = DtoToEntityIMapper.Map <AnnouncementDto, Announcement>(announcementDto); ////
UoW.GetRepository <Announcement>().Insert(announcement);
await UoW.SaveAsync();
return(CreatedAtRoute("DefaultApi", new { id = announcement.ID }, announcement));
}
public Task <AnnouncementDto> GetAnnouncementById(Guid id)
{
var query = _announcementRepository.FirstOrDefault(t => t.Id == id);
if (query == null)
{
throw new UserFriendlyException("该公告不存在！");
}
var output = new AnnouncementDto();
return(Task.FromResult(ObjectMapper.Map(query, output)));
}
public static void PushToUsers(string[] whos, AnnouncementDto message, PlanetHub hub)
{
IHubConnectionContext <dynamic> clients = GetClients(hub);
for (int i = 0; i < whos.Length; i++)
{
var who = whos[i];
foreach (var connectionId in _connections.GetConnections(who))
{
clients.Client(connectionId).addChatMessage(message);
}
}
}
public async Task SendMessageToClient(AnnouncementDto message, string userReceiveMessage)
{
try
{
await _chatMobileHubContext.Clients.User(userReceiveMessage)
.SendAsync("ReceiveMessage", message);
}
catch (Exception ex)
{
Logger.Warn("Internal Server Error");
Logger.Warn("Could not send chat message to user");
Logger.Warn(ex.ToString(), ex);
}
}
public async Task <ActionResult <AnnouncementDto> > PostAnnouncement([FromBody] AnnouncementDto announcementDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Announcement announcement = DtoToEntityIMapper.Map <AnnouncementDto, Announcement>(announcementDto);
repository.Add(announcement);
await uoW.SaveAsync();
return(CreatedAtAction("GetAnnouncement", new { id = announcement.ID }, announcementDto));
}
public async Task <List <Announcement> > GetListPropertyAsync(AnnouncementDto dto, CancellationToken token = default)
{
using (var db = new GuoGuoCommunityContext())
{
var list = await db.Announcements.Where(x => x.IsDeleted == false && x.DepartmentValue == dto.DepartmentValue).ToListAsync(token);
if (!string.IsNullOrWhiteSpace(dto.Title))
{
list = list.Where(x => x.Title.Contains(dto.Title)).ToList();
}
list = list.Where(x => x.CreateOperationTime >= dto.StartTime && x.CreateOperationTime <= dto.EndTime).ToList();
return(list.Where(x => x.SmallDistrictId == dto.SmallDistrictId).ToList());
}
}
public async Task <AnnouncementDto> GetByIdAsync(Guid id)
{
var announcement = await _context.Announcements.FirstOrDefaultAsync(a => a.Id == id);
var filteredAnnouncement = new AnnouncementDto
{
Id = announcement.Id,
Subject = announcement.Subject,
Type = announcement.Type,
CreatedAt = announcement.CreatedAt,
UserName = announcement.Author.UserName
};
return(filteredAnnouncement);
}
public async Task UpdateAnnouncementAsync(int id, AnnouncementDto announcementDto)
{
var announcement = await _unitOfWork.Repository <AnnouncementEntity>().Get(p => p.Id == id);
if (announcement == null)
{
throw new ArgumentNullException(
$"Error while updating Announcement. Announcement with id {nameof(id)}={id} not found");
}
announcement.Title = announcementDto.Title;
announcement.Description = announcementDto.Description;
_unitOfWork.Repository <AnnouncementEntity>().Update(announcement);
await _unitOfWork.SaveChangesAsync();
}
public async Task <ActionResult <AnnouncementDto> > GetAnnouncement([FromRoute] int id)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var announcement = await repository.GetAsync(a => a.ID == id);
if (announcement == null)
{
return(NotFound());
}
AnnouncementDto announcementDto = EntityToDtoIMapper.Map <Announcement, AnnouncementDto>(announcement);
return(Ok(announcementDto));
}
public async Task SendMessage(AnnouncementDto message)
{
try
{
await Clients.All.SendAsync("ReceiveMessage", AbpSession.UserId, message);
}
catch (UserFriendlyException ex)
{
Logger.Warn("Could not send chat message to user");
Logger.Warn(ex.ToString(), ex);
}
catch (Exception ex)
{
Logger.Warn("Internal Server Error");
Logger.Warn("Could not send chat message to user");
Logger.Warn(ex.ToString(), ex);
}
}
private async Task RunAnnounceLoopAsync()
{
await TaskEx.YieldToThreadPool();
var announce = new AnnouncementDto {
Identity = identity
};
while (!shutdownCancellationToken.IsCancellationRequested)
{
try {
await payloadSender.BroadcastAsync(announce).ConfigureAwait(false);
await Task.Delay(kAnnounceIntervalMillis, shutdownCancellationToken).ConfigureAwait(false);
} catch (OperationCanceledException) {
// shutdown cancellation token cancelled
}
}
}
public async Task <IActionResult> PutAnnouncement([FromRoute] int number, [FromBody] AnnouncementDto announcementDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (number != announcementDto.Number)
{
return(BadRequest());
}
var result = await _repositoryAnnouncement.GetList();
var list = result.ToList();
try
{
var annTmp = list.FirstOrDefault(x => x.Number == number);
if (annTmp == null)
{
return(NotFound());
}
annTmp.Text = announcementDto.Text;
annTmp.CreationDateTime = DateTime.Now;
annTmp.Rate = 1;
await _repositoryAnnouncement.Update(annTmp);
_repositoryAnnouncement.Save();
return(Ok(announcementDto));
}
catch (DbUpdateConcurrencyException)
{
if (list.Any(x => x.Number == number))
{
return(NotFound());
}
else
{
return(NoContent());
}
}
}
public async Task <IActionResult> CreateAnnouncement([FromBody] AnnouncementDto announcementDto)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var announcement = Mapper.Map <AnnouncementDto, Announcement>(announcementDto);
announcement.Timestamp = DateTime.Now.ToString();
_context.Announcements.Add(announcement);
await _context.SaveChangesAsync();
announcement = await _context.Announcements.FindAsync(announcement.Id);
var result = Mapper.Map <Announcement, AnnouncementDto>(announcement);
var body = new
{
notification = new
{
body = $"New Announcement: {announcement.caption}",
title = $"{announcement.DisplayName}"
},
priority = "high",
data = new
{
clickaction = "FLUTTERNOTIFICATIONCLICK",
id = "1",
status = "done"
},
to = "/topics/all"
};
ClientFireBase.DefaultRequestHeaders.Authorization =
new AuthenticationHeaderValue("key", "=AAAAV02ojhg:APA91bGng1U47tjWoEhKszz5FqOqxwSMGDy8XB5ILjWaKdpcdUBTxi4hHjbX_mV6UbVFsm4zr-CoA0Hzx0i2763ADlNnU5XuX578ObGjo1CEXlWvjlISev3_9Cpgtg_tNOBtqe6hhsqT");
var response = await ClientFireBase.PostAsync("fcm/send", new StringContent(
JsonConvert.SerializeObject(body),
Encoding.UTF8, "application/json"));
var retFireBase = await response.Content.ReadAsStringAsync();
return(Ok(result));
}
public async Task <Announcement> AddVipOwnerAsync(AnnouncementDto dto, CancellationToken token = default)
{
using (var db = new GuoGuoCommunityContext())
{
if (!Guid.TryParse(dto.OwnerCertificationId, out var ownerCertificationId))
{
throw new NotImplementedException("业主认证Id不正确！");
}
var ownerCertificationRecord = await db.OwnerCertificationRecords.Include(x => x.Industry.BuildingUnit.Building.SmallDistrict.Community.StreetOffice).Where(x => x.Id == ownerCertificationId && x.IsDeleted == false).FirstOrDefaultAsync(token);
if (ownerCertificationRecord == null)
{
throw new NotImplementedException("业主认证信息不存在！");
}
var entity = db.Announcements.Add(new Announcement
{
Content = dto.Content,
SmallDistrictArray = ownerCertificationRecord.Industry.BuildingUnit.Building.SmallDistrictId.ToString(),
DepartmentName = dto.DepartmentName,
DepartmentValue = dto.DepartmentValue,
Summary = dto.Summary,
Title = dto.Title,
CreateOperationTime = dto.OperationTime,
CreateOperationUserId = dto.OperationUserId,
LastOperationTime = dto.OperationTime,
LastOperationUserId = dto.OperationUserId,
CommunityId = ownerCertificationRecord.Industry.BuildingUnit.Building.SmallDistrict.CommunityId.ToString(),
CommunityName = ownerCertificationRecord.Industry.BuildingUnit.Building.SmallDistrict.Community.Name,
SmallDistrictId = ownerCertificationRecord.Industry.BuildingUnit.Building.SmallDistrictId.ToString(),
SmallDistrictName = ownerCertificationRecord.Industry.BuildingUnit.Building.SmallDistrict.Name,
StreetOfficeId = ownerCertificationRecord.Industry.BuildingUnit.Building.SmallDistrict.Community.StreetOfficeId.ToString(),
StreetOfficeName = ownerCertificationRecord.Industry.BuildingUnit.Building.SmallDistrict.Community.StreetOffice.Name,
OwnerCertificationId = dto.OwnerCertificationId
});
await db.SaveChangesAsync(token);
return(entity);
}
}
public async Task DeleteAsync(AnnouncementDto dto, CancellationToken token = default)
{
using (var db = new GuoGuoCommunityContext())
{
if (!Guid.TryParse(dto.Id, out var uid))
{
throw new NotImplementedException("公告信息不正确！");
}
var announcement = await db.Announcements.Where(x => x.Id == uid && x.IsDeleted == false).FirstOrDefaultAsync(token);
if (announcement == null)
{
throw new NotImplementedException("该公告不存在！");
}
announcement.LastOperationTime = dto.OperationTime;
announcement.LastOperationUserId = dto.OperationUserId;
announcement.DeletedTime = dto.OperationTime;
announcement.IsDeleted = true;
await db.SaveChangesAsync(token);
}
}
public async Task <IActionResult> PostAnnouncement([FromBody] AnnouncementDto announcement)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await _repositoryUser.GetList();
var enumerable = result.ToList();
if (!(enumerable.Count() < _maxCountAnnouncement))
{
return(CreatedAtAction("GetAnnouncement", new { number = announcement.Number },
"Превышен лимит количества объявлений в ситсеме"));
}
var user = enumerable.FirstOrDefault(x => x.Name == announcement.UserName);
if (user == null)
{
user = new User()
{
Name = announcement.UserName, UserId = new Guid()
};
await _repositoryUser.Create(user);
}
Announcement annTmp = new Announcement()
{
AnnouncementId = new Guid(), CreationDateTime = DateTime.Now,
Number = enumerable.Count() + 1,
Rate = 1,
Text = announcement.Text,
User = user
};
await _repositoryAnnouncement.Create(annTmp);
_repositoryAnnouncement.Save();
return(CreatedAtAction("GetAnnouncement", new { number = announcement.Number }, announcement));
}
public IHttpActionResult Create(AnnouncementDto announcement)
{
return(CreateResponse(() =>
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
announcement.DateCreated = DateTime.Now;
var model = Mapper.Map <Announcement>(announcement);
_announcementService.Add(model);
UnitOfWork.Commit();
announcement.Id = model.Id;
PlanetHub.PushToAllUsers(announcement, null);
return Created(new Uri(Request.RequestUri + "/" + announcement.Id), announcement);
}));
}
public IEnumerable <Announcement> SaveAnnouncement(AnnouncementDto obj)
{
if (obj.ChpaterId.Count > 0)
{
foreach (var item in obj.ChpaterId)
{
_context.Announcement.Add(new Announcement
{
PlainText = obj.PlainText,
Text = obj.Text,
ChpaterId = item.ChapterId,
CreatedBy = obj.CreatedBy,
StartDate = obj.StartDate,
EndDate = obj.EndDate,
ModifiedBy = obj.ModifiedBy,
ModifiedDate = new DateTime().ToString()
});
_context.SaveChanges();
}
}
else
{
_context.Announcement.Add(new Announcement
{
PlainText = obj.PlainText,
Text = obj.Text,
CreatedBy = obj.CreatedBy,
StartDate = obj.StartDate,
EndDate = obj.EndDate,
ModifiedBy = obj.ModifiedBy,
ModifiedDate = new DateTime().ToString()
});
_context.SaveChanges();
}
return(_context.Announcement.ToList());
}
private void HandleAnnouncement(UdpClientRemoteInfo remoteInfo, AnnouncementDto x)
{
announcementsReceivedCounter.Increment();
var peerIdentity = x.Identity;
var peerId = peerIdentity.Id;
bool isNewlyDiscoveredRoute = false;
RoutingContext addedRoutingContext = null;
UdpUnicaster addedUnicaster = null;
var routingContext = routingContextsByPeerId.GetOrAdd(
peerId,
add => {
isNewlyDiscoveredRoute = true;
var unicastReceivePort = int.Parse((string)x.Identity.Properties[UdpConstants.kUnicastPortIdentityPropertyKey]);
var unicastIpAddress = remoteInfo.IPEndpoint.Address;
var unicastEndpoint = new IPEndPoint(unicastIpAddress, unicastReceivePort);
var unicastRemoteInfo = new UdpClientRemoteInfo {
Socket = remoteInfo.Socket,
IPEndpoint = unicastEndpoint
};
addedUnicaster = udpUnicasterFactory.Create(unicastRemoteInfo);
return(addedRoutingContext = new RoutingContext(addedUnicaster));
});
if (addedRoutingContext == routingContext)
{
addedUnicaster.Initialize();
}
if (isNewlyDiscoveredRoute)
{
routingTable.Register(peerId, routingContext);
}
peerTable.GetOrAdd(peerId).HandleInboundPeerIdentityUpdate(peerIdentity);
}
public Task <List <Announcement> > GetListAsync(AnnouncementDto dto, CancellationToken token = default)
{
throw new NotImplementedException();
}
public Task UpdateAsync(AnnouncementDto dto, CancellationToken token = default)
{
throw new NotImplementedException();
}
public async Task <ActionResult <AnnouncementDto> > PutAnnouncement([FromRoute] int id, [FromBody] AnnouncementDto announcementDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != announcementDto.ID)
{
return(BadRequest());
}
Announcement announcement = DtoToEntityIMapper.Map <AnnouncementDto, Announcement>(announcementDto);
repository.ModifyEntryState(announcement, EntityState.Modified);
try
{
await uoW.SaveAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AnnouncementExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
