public async Task <IActionResult> Markers(int competitionId, int competitionInstanceId, int eventId, int heatId)
{
await _markerService.GetMarkersFromTimingDb(competitionInstanceId);
var assignedMarkers = _markerService.GetMarkersForHeat(heatId);
var markerList = _markerService.GetUnAssignedMarkersForHeat(heatId, competitionInstanceId);
var competition = await _competitionService.GetCompetitionByIdAsync(competitionId);
var competitionInstance = await _competitionService.GetCompetitionInstanceByIdAsync(competitionInstanceId);
var _event = await _eventService.GetEventByIdAsync(eventId);
var heat = await _heatService.GetHeatByIdAsync(heatId);
var data = new MarkerDto
{
AssignedMarkers = assignedMarkers,
MarkerList = markerList,
CompetitionName = competition.Name,
CompetitionInstanceName = competitionInstance.Name,
EventName = _event.Name,
HeatNumber = heat.HeatNumber
};
return(View(data));
}
public Marker(MarkerDto marker)
{
this.Type = marker.Type;
this.Coordinates = marker.Coordinates;
this.TooltipContent = marker.TooltipContent;
this.Radius = marker.Radius;
}
public async Task <IHttpActionResult> Post(MarkerDto markerDto)
{
if (!ModelState.IsValid)
{
return(Json(new { Error = "Please input all fields" }));
}
var context = new FoodSignalingContext(); //could use dependency injection here
var marker = new Marker()
{
Organization = markerDto.Organization,
Hour = markerDto.TimeHour,
Minute = markerDto.TimeMinute,
WeekDays = markerDto.WeekDays,
Location = new GeoJsonPoint <GeoJson2DGeographicCoordinates>(
new GeoJson2DGeographicCoordinates(markerDto.Lng, markerDto.Lat))
};
await context.Markers.InsertOneAsync(marker);
markerDto.Id = marker.Id;
return(Json(markerDto));
}
public MarkerViewModel Add(MarkerDto markerDto)
{
Marker marker = new Marker
{
Id = markerDto.Id,
Description = markerDto.Description,
Image = markerDto.Image != null?Convert.FromBase64String(markerDto.Image) : null,
Latitude = markerDto.Latitude,
Longitude = markerDto.Longitude,
CreatedAt = DateTime.Now,
Solved = markerDto.Solved,
CreatedByCitizenId = _context.Citizens.SingleOrDefault(c => c.Name == markerDto.CreatedByCitizen).Id
};
_context.Markers.Add(marker);
_context.SaveChanges();
MarkerViewModel markerViewModel = new MarkerViewModel
{
Id = marker.Id,
Description = marker.Description,
Latitude = marker.Latitude,
Longitude = marker.Longitude,
Solved = marker.Solved,
CreatedAt = marker.CreatedAt,
CreatedByCitizen = marker.CreatedByCitizen.Name,
Image = marker.Image
};
return(markerViewModel);
}
public void UpdateMarker(MarkerDto newMarker)
{
MarkerType _markerType = dal.GetMarkerType(newMarker.MarkerType);
Address address;
if (IsSuchAddress(newMarker.City, newMarker.Street, newMarker.Number))
{
address = dal.GetQueryableAddress(newMarker.City, newMarker.Street, newMarker.Number).FirstOrDefault();
}
else
{
City _city = dal.GetCity(newMarker.City);
address = dal.AddNewAddress(_city, newMarker.Street, newMarker.Number);
}
Login login = dal.GetLoginByName(newMarker.UserName);
Marker marker = new Marker()
{
Name = newMarker.Name,
Address = address,
Description = newMarker.Description,
Lat = newMarker.Lat,
Lng = newMarker.Lng,
Login = login,
Picture = newMarker.Picture,
Type = _markerType
};
dal.UpdateMarker(newMarker.Id, marker, newMarker.Contacts);
}
public async Task SendUpdateMarker(MarkerDto marker)
{
UpdateMarkerWebSocketResponse response = new UpdateMarkerWebSocketResponse
{
Marker = marker
};
string msg = JsonConvert.SerializeObject(response);
await InfraMessenger.SendAll(msg);
}
public Marker Create(MarkerDto dto)
{
if (!ModelState.IsValid && dto == null)
return null;
string errors = null;
var marker = _repo.Create(dto, out errors);
// todo: should return generic dto with object entity and errors
return marker;
}
public async Task <MarkerDto> UpdateMarker(MarkerDto marker)
{
var markerInDb = await _markerRepository.GetWithThrow(u => u.Id == marker.Id);
_mapper.Map(marker, markerInDb);
await _unitOfWork.CompleteAsync();
var mappedMarker = _mapper.Map <Marker, MarkerDto>(markerInDb);
return(mappedMarker);
}
public ActionResult <MarkerViewModel> CreateMarker([FromBody] MarkerDto markerDto)
{
if (ModelState.IsValid)
{
var markerViewModel = _markerRepo.Add(markerDto);
return(Ok(markerViewModel));
}
else
{
return(BadRequest("ModelState is not valid"));
}
}
public async Task <MarkerDto> CreateMarker(MarkerDto marker)
{
if (marker == null)
{
throw new InvalidOperationException();
}
var markerInDb = _mapper.Map <MarkerDto, Marker>(marker);
markerInDb.IsActive = true;
_markerRepository.Add(markerInDb);
await _unitOfWork.CompleteAsync();
return(_mapper.Map <Marker, MarkerDto>(markerInDb));
}
public async Task <IActionResult> CreateMarker([FromBody] MarkerDto marker)
{
var response = new Response <MarkerDto>();
try
{
response.Object = await _markerService.CreateMarker(marker);
}
catch (InvalidOperationException e)
{
response.IsError = true;
response.ErrorMessage = "Data provided by client is not valid";
_logger.LogError($"MarkerController | Error | Error message : {e.Message}");
}
return(Ok(response));
}
public Response GetMarkers(GetMarkersRequest request)
{
List <MarkerDto> markersList = new List <MarkerDto>();
try
{
var dataSet = _dal.GetMarkers(request);
var table = dataSet.Tables[0];
for (int i = 0; i < dataSet.Tables[0].Rows.Count; i++)
{
MarkerDto temp = new MarkerDto()
{
DocId = table.Rows[i]["DocId"].ToString(),
MarkerId = table.Rows[i]["MarkerId"].ToString(),
MarkerType = table.Rows[i]["MarkerType"].ToString(),
ForColor = table.Rows[i]["ForColor"].ToString(),
BackColor = table.Rows[i]["BackColor"].ToString(),
UserId = table.Rows[i]["UserId"].ToString(),
LocationX = Convert.ToDouble(table.Rows[i]["LocationX"].ToString()),
LocationY = Convert.ToDouble(table.Rows[i]["LocationY"].ToString()),
Height = Convert.ToDouble(table.Rows[i]["Height"].ToString()),
Width = Convert.ToDouble(table.Rows[i]["Width"].ToString())
/*
* LocationX = Convert.ToInt32((decimal)table.Rows[i]["LocationX"]),
* LocationY = Convert.ToInt32((decimal)table.Rows[i]["LocationY"]),
* Height = Convert.ToInt32((decimal)table.Rows[i]["Height"]),
* Width= Convert.ToInt32((decimal)table.Rows[i]["Width"])
*/
};
markersList.Add(temp);
}
GetMarkersResponseOk ret = new GetMarkersResponseOk
{
Markers = markersList.ToArray()
};
return(ret);
}
catch (Exception ex)
{
return(new AppResponseError(ex.Message));
}
}
public async Task <IActionResult> UpdateMarker([FromBody] MarkerDto marker)
{
var response = new Response <MarkerDto>();
_logger.LogError($"MarkerController | INFO | Updating : {marker.Id}");
try
{
response.Object = await _markerService.UpdateMarker(marker);
}
catch (InvalidOperationException e)
{
response.IsError = true;
response.ErrorMessage = "There is no marker with given identification";
_logger.LogError($"MarkerController | Error | Error message : {e.Message}");
}
return(Ok(response));
}
public void UpdateMarker(MarkerWcf newMarker)
{
MarkerDto markerDto = new MarkerDto()
{
Id = newMarker.Id,
Name = newMarker.Name,
City = newMarker.City,
Street = newMarker.Street,
Number = newMarker.Number,
Description = newMarker.Description,
Lat = newMarker.Lat,
Lng = newMarker.Lng,
UserName = newMarker.UserName,
Picture = newMarker.Picture,
MarkerType = newMarker.MarkerType,
Contacts = newMarker.Contacts
};
bll.UpdateMarker(markerDto);
}
public async Task<IHttpActionResult> Post(MarkerDto markerDto)
{
if (!ModelState.IsValid)
return Json(new { Error = "Please input all fields" });
var context = new FoodSignalingContext(); //could use dependency injection here
var marker = new Marker()
{
Organization = markerDto.Organization,
Hour = markerDto.TimeHour,
Minute = markerDto.TimeMinute,
WeekDays = markerDto.WeekDays,
Location = new GeoJsonPoint<GeoJson2DGeographicCoordinates>(
new GeoJson2DGeographicCoordinates(markerDto.Lng, markerDto.Lat))
};
await context.Markers.InsertOneAsync(marker);
markerDto.Id = marker.Id;
return Json(markerDto);
}
public MarkerDto[] GetAllMarkersDto()
{
Marker[] markers = ctx.Markers.ToArray();
Mapper.Reset();
Mapper.Initialize(cfg => cfg.CreateMap <Marker, MarkerDto>()
.ForMember(x => x.City, opt => opt.MapFrom(src => src.Address.City.Name))
.ForMember(x => x.Street, opt => opt.MapFrom(src => src.Address.Street))
.ForMember(x => x.Number, opt => opt.MapFrom(src => src.Address.Number))
.ForMember(x => x.MarkerType, opt => opt.MapFrom(src => src.Type.Name))
.ForMember(x => x.UserName, opt => opt.MapFrom(src => src.Login.Name))
.ForMember(x => x.Contacts, opt => opt.MapFrom(src => src.Contacts.Select(item => item.Name).ToArray()))
);
List <MarkerDto> markersDto = new List <MarkerDto>();
// Выполняем сопоставление
foreach (var item in markers)
{
MarkerDto markerDto = Mapper.Map <Marker, MarkerDto>(item);
markersDto.Add(markerDto);
}
return(markersDto.ToArray());
}
public Marker Create(MarkerDto dto, out string error)
{
error = null;
using (var tr = new TransactionScope())
{
try
{
var userId = _db.CurrentUserId();
var user = _db.Users.Single(x => x.Id == userId);
var opinion = new MarkerOpinion
{
Author = user,
Opinion = dto.Text,
Timestamp = DateTime.Now
};
Marker marker;
if (dto.Id == null) // new marker
{
marker = new Marker
{
Height = dto.Height,
Width = dto.Width,
X = dto.X,
Y = dto.Y,
Number = _db.Markers.Include(x => x.Node)
.Where(x => x.Node.Id == dto.NodeId)
.Count() + 1,
Node = _db.Nodes.Include("Project.Owner").SingleOrDefault(n => n.Id == dto.NodeId)
};
_db.Markers.Add(marker);
}
else // adding opinion to existing marker
{
marker = _db.Markers.Include("Node").Include("Node.Project.Owner").Single(x => x.Id == dto.Id);
}
opinion.Marker = marker;
marker.Opinions.Add(opinion);
_db.MarkersOpinions.Add(opinion);
_db.SaveChanges();
_notificationsRepository.Create(new Notification
{
Author = user,
Header = "Node: new opinion",
Priority = 4,
ProjectId = marker.Node.Project.Id,
Link = "/project/" + marker.Node.Project.Id + "/markers/" + marker.Node.Id
});
var permision = _permissionsRepository.GetPermission(_db.CurrentUserId(), marker.Node.Project.Id);
if (marker.Node.Project.Owner.Id != _db.CurrentUserId())
if (permision == null || permision.AddMarkers == false)
{
return null;
}
tr.Complete();
return marker;
}
catch (Exception e)
{
error = "DB_ERROR :" + e.Message;
return null;
}
}
}
public async Task <bool> Post([FromBody] MarkerDto marker)
{
return(await _markerService.AddMarker(marker));
}
