public IActionResult Edit(IncidentViewModel viewModel)
{
string Action = "Edit";
if (viewModel.CurrentIncident.IncidentID == 0)
{
Action = "Add";
}
if (ModelState.IsValid)
{
if (viewModel.CurrentIncident.IncidentID == 0)
{
context.Incidents.Add(viewModel.CurrentIncident);
}
else
{
context.Incidents.Update(viewModel.CurrentIncident);
}
context.SaveChanges();
TempData["message"] = $" Incident {Action}ed.";
return(RedirectToAction("Index", "Incidents"));
}
else
{
viewModel.Action = Action;
viewModel.Customers = context.Customers.OrderBy(c => c.FirstName).ToList();
viewModel.Technicians = context.Technicians.OrderBy(c => c.Name).ToList();
viewModel.Products = context.Products.OrderBy(p => p.Name).ToList();
return(View(viewModel));
}
}
public ViewResult Get()
{
HttpContext.Session.Remove("sessionID");
Incident activeIncident = new Incident();
Technician activeTechnician = new Technician();
var model = new IncidentViewModel
{
ActiveIncident = activeIncident,
ActiveTechnician = activeTechnician,
Incidents = context.Incidents.ToList(),
Technicians = context.Technicians.ToList(),
Customers = context.Customers.ToList(),
Products = context.Products.ToList()
};
IQueryable <Incident> query = context.Incidents;
if (activeIncident.IncidentID != 0)
{
query = query.Where(i => i.IncidentID == activeIncident.IncidentID);
}
if (activeTechnician.TechnicianID != 0)
{
query = query.Where(i => i.Technician.TechnicianID == activeTechnician.TechnicianID);
}
model.Incidents = query.ToList();
return(View(model));
}
public IActionResult Edit(IncidentViewModel vm)
{
string action = vm.Action;
if (ModelState.IsValid)
{
if (action == "Add")
{
unitOfWork.IncidentRepository.Insert(vm.CurrentIncident);
TempData["message"] = vm.CurrentIncident.Title + " Added!";
}
else
{
unitOfWork.IncidentRepository.Update(vm.CurrentIncident);
TempData["message"] = vm.CurrentIncident.Title + " Updated!";
}
unitOfWork.Save();
return(RedirectToAction("List", "Incident"));
}
else
{
vm.Customers = unitOfWork.CustomerRepository.Get(orderBy: c => c.OrderBy(q => q.Firstname)).ToList();
vm.Products = unitOfWork.ProductRepository.Get(orderBy: p => p.OrderBy(q => q.Name)).ToList();
vm.Technicians = unitOfWork.TechnicianRepository.Get(orderBy: t => t.OrderBy(q => q.Name)).ToList();
return(View(vm));
}
}
public ViewResult List()
{
string FilterString = HttpContext.Session.GetString("FilterString");
Incident activeIncident = new Incident();
Technician activeTechnician = new Technician();
var model = new IncidentViewModel
{
ActiveIncident = activeIncident,
ActiveTechnician = activeTechnician,
Incidents = context.Incidents.ToList(),
Technicians = context.Technicians.ToList(),
Customers = context.Customers.ToList(),
Products = context.Products.ToList()
};
IQueryable <Incident> query = context.Incidents;
if (FilterString != null)
{
if (FilterString == "unassigned")
{
query = query.Where(i => i.TechnicianID == null);
}
if (FilterString == "open")
{
query = query.Where(i => i.DateClosed == null);
}
}
model.Incidents = query.ToList();
return(View(model));
}
public ViewResult List(string activeIncident = "All", string activeTechnician = "All")
{
string FilterString = HttpContext.Session.GetString("FilterString");
var model = new IncidentViewModel
{
ActiveIncident = activeIncident,
ActiveTechnician = activeTechnician,
Incidents = context.Incidents.OrderBy(i => i.Title).ToList(),
Technicians = context.Technicians.OrderBy(c => c.Name).ToList(),
Customers = context.Customers.OrderBy(c => c.FirstName).ToList(),
Products = context.Products.OrderBy(p => p.Name).ToList(),
};
IQueryable <Incident> query = context.Incidents;
if (FilterString != "null")
{
if (FilterString != "unassigned")
{
query = query.Where(i => i.TechnicianID == null);
}
if (FilterString != "open")
{
query = query.Where(i => i.DateClosed == null);
}
}
model.Incidents = query.ToList();
return(View(model));
}
public Task BindModelAsync(ModelBindingContext bindingContext)
{
if (bindingContext == null)
{
throw new ArgumentNullException(nameof(bindingContext));
}
string incident = bindingContext.HttpContext.Request.Form["incident"];
IncidentViewModel incidentModel = JsonConvert.DeserializeObject <IncidentViewModel>(incident);
if (bindingContext.HttpContext.Request.Form.Files.Count > 0)
{
incidentModel.AttachedFiles = new List <AttachedFileViewModel>(bindingContext.HttpContext.Request.Form.Files.Count);
foreach (var file in bindingContext.HttpContext.Request.Form.Files)
{
incidentModel.AttachedFiles.Add(new AttachedFileViewModel
{
ContentType = file.ContentType,
Name = file.FileName,
FormFile = file
});
}
}
bindingContext.Result = ModelBindingResult.Success(incidentModel);
return(Task.CompletedTask);
}
public IActionResult Add()
{
//ViewBag.Action = "Add";
//StoreListsInViewBag();
//Instantiate new IncidentViewModel and set the list of
//Customers, Technicians, and Products along with setting
//the Action property to Add
IncidentViewModel model = new IncidentViewModel();
model.Incident = new Incident();
model.Action = "Add";
model.Customers = context.Customers
.OrderBy(c => c.FirstName)
.ToList();
model.Products = context.Products
.OrderBy(p => p.Name)
.ToList();
model.Technicians = context.Technicians
.OrderBy(t => t.Name)
.ToList();
return(View("AddEdit", model));
}
public IActionResult List(int technicianId)
{
int?sessionID = HttpContext.Session.GetInt32("sessionID");
if (technicianId == 0 && sessionID == null)
{
TempData["message"] = "Would you like to select a technician? Go ahead, you can do that now.";
return(RedirectToAction("Get"));
}
else
{
if (technicianId == 0)
{
technicianId = (int)sessionID;
}
var model = new IncidentViewModel();
model.ActiveTechnician = context.Technicians.Find(technicianId);
model.Customers = context.Customers.ToList();
model.Products = context.Products.ToList();
IQueryable <Incident> query = context.Incidents;
query = query.Where(i => i.TechnicianID == model.ActiveTechnician.TechnicianID);
query = query.Where(i => i.DateClosed == null);
model.Incidents = query.ToList();
if (model.Incidents.Count == 0)
{
TempData["message"] = $"No open incidents for this technician.";
}
return(View(model));
}
}
public IActionResult Edit(int id)
{
//ViewBag.Action = "Edit";
//StoreListsInViewBag();
//Instantiate a new IncidentViewModel that set the Incident property
//to the current INcident object for the id parameter, the Action to
//"Edit" and set the list of Customers, Technicians, and Products
IncidentViewModel model = new IncidentViewModel();
var incident = context.Incidents.Find(id);
model.Incident = incident;
model.Action = "Edit";
model.Customers = context.Customers
.OrderBy(c => c.FirstName)
.ToList();
model.Products = context.Products
.OrderBy(p => p.Name)
.ToList();
model.Technicians = context.Technicians
.OrderBy(t => t.Name)
.ToList();
//var product = context.Incidents.Find(id);
return(View("AddEdit", model));
}
public async Task <IActionResult> Create([FromForm] IncidentViewModel incidentViewModel)
{
if (incidentViewModel.Description.ToLower().Contains("space") &&
incidentViewModel.Description.ToLower().Contains("invader"))
{
return(RedirectToAction("Index", "Invaders"));
}
var imageName = $"{Guid.NewGuid().ToString()}.jpg";
var imageStream = new MemoryStream();
incidentViewModel.File.CopyTo(imageStream);
imageStream.Position = 0;
var newIncidentInput = new CreateIncidentInput
{
Description = incidentViewModel.Description,
Longitude = incidentViewModel.Longitude,
Latitude = incidentViewModel.Latitude,
Time = DateTime.Now,
ImageName = imageName,
ImageBytes = ReadFully(imageStream)
};
_incidentAppService.RecordNewIncident(newIncidentInput);
await _imageStorageService.UploadImageBytes(imageName, imageStream.GetAllBytes());
return(View("Index"));
}
public ViewResult Get()
{
Incident activeIncident = new Incident();
Technician activeTechnician = new Technician();
var model = new IncidentViewModel
{
ActiveIncident = activeIncident,
ActiveTechnician = activeTechnician,
Incidents = Context.Incidents.ToList(),
Technicians = Context.Technicians.ToList(),
Customers = Context.Customers.ToList(),
Products = Context.Products.ToList(),
};
IQueryable <Incident> query = Context.Incidents;
if (activeIncident.IncidentID != 0)
{
query = query.Where(t =>
t.IncidentID ==
activeIncident.IncidentID);
}
if (activeTechnician.TechnicianID != 0)
{
query = query.Where(t =>
t.Technician.TechnicianID ==
activeTechnician.TechnicianID);
}
model.Incidents = query.ToList();
return(View(model));
}
public ViewResult Get()
{
var incidentOptions = new QueryOptions <Incident> {
Includes = "Customer,Product"
};
var technicianOptions = new QueryOptions <Technician>();
var customerOptions = new QueryOptions <Customer>();
var productOptions = new QueryOptions <Product>();
HttpContext.Session.Remove("sessionID");
Incident activeIncident = new Incident();
Technician activeTechnician = new Technician();
var model = new IncidentViewModel
{
ActiveIncident = activeIncident,
ActiveTechnician = activeTechnician,
Incidents = data.Incidents.List(incidentOptions),
Technicians = data.Technicians.List(technicianOptions),
Customers = data.Customers.List(customerOptions),
Products = data.Products.List(productOptions)
};
return(View(model));
}
public ViewResult Edit(int id)
{
Incident activeIncident = data.Incidents.Get(id);
var model = new IncidentViewModel
{
ActiveIncident = activeIncident,
Incidents = data.Incidents.List(new QueryOptions <Incident>
{
Includes = "Customer,Product",
WhereClauses = new WhereClauses <Incident>
{
{ t => t.IncidentID == id }
}
}),
Technicians = data.Technicians.List(new QueryOptions <Technician>()),
Customers = data.Customers.List(new QueryOptions <Customer>()),
Products = data.Products.List(new QueryOptions <Product>()),
Action = "Edit"
};
HttpContext.Session.SetInt32("sessionID", (int)model.ActiveIncident.TechnicianID);
return(View("Edit", model));
}
public IActionResult Save(Incident incident)
{
if (ModelState.IsValid)
{
if (incident.IncidentID == 0)
{
data.Insert(incident);
}
else
{
data.Update(incident);
}
data.Save();
return(RedirectToAction("List"));
}
else
{
IncidentViewModel model = new IncidentViewModel
{
Incident = incident
};
if (incident.IncidentID == 0)
{
model.Action = "Add";
}
else
{
model.Action = "Edit";
}
return(View("AddEdit", model));
}
}
public async Task <bool> CreateIncident(IncidentViewModel model)
{
Incident incident = new Incident();
incident = IncidentViewModelToIncident(incident, model);
if (model.AttachedFiles != null && model.AttachedFiles.Count > 0)
{
incident.AttachedFiles = new List <IncidentFile>(model.AttachedFiles.Count);
foreach (var attachedFile in model.AttachedFiles)
{
attachedFile.Name = $"{incident.Title}_{attachedFile.Name}";
string path = "/images/incidents/" + attachedFile.Name;
using (var fileStream = new FileStream(_hostingEnvironment.WebRootPath + path, FileMode.Create))
{
await attachedFile.FormFile.CopyToAsync(fileStream);
incident.AttachedFiles.Add(new IncidentFile
{
IncidentId = incident.Id,
Name = attachedFile.Name,
ContentType = attachedFile.ContentType,
FilePath = path,
UploadedById = _userHelper.GetUserId()
});
}
}
}
await _incidentsRepository.AddAsync(incident);
return(await _incidentsRepository.SaveChangesAsync());
}
public IActionResult Delete(IncidentViewModel vm)
{
unitOfWork.IncidentRepository.Delete(vm.CurrentIncident);
TempData["message"] = vm.CurrentIncident.Title + " Deleted!";
unitOfWork.Save();
return(RedirectToAction("List", "Incident"));
}
public async Task <IncidentModel> CreateIncidentAsync(IncidentViewModel model)
{
transactionService.Begin();
var account = await accountService.GetAccountAsync(model.AccountName);
if (account == null)
{
throw new NullReferenceException($"Account with email: {model.Email} - not exist.");
}
var contactVM = mapper.Map <ContactViewModel>(model);
var contactHandlerResult = await accountService.AddContact(model.AccountName, contactVM);
var incident = new IncidentModel()
{
Description = model.Description
};
incident = await incidentRepository.CreateAsync(incident);
account.IncidentName = incident.Name;
var accountHandlerResult = await accountService.UpdateAccountAsync(account);
if (contactHandlerResult.IsDone && accountHandlerResult.IsDone)
{
transactionService.Commit();
}
else
{
transactionService.Rollback();
}
return(incident);
}
public IActionResult List(int TechnicianId)
{
int?sessionID = HttpContext.Session.GetInt32("sessionID");
if (TechnicianId == 0 && sessionID == null)
{
TempData["message"] = $"Please select a Technician.";
return(RedirectToAction("Get"));
}
else
{
if (TechnicianId == 0)
{
TechnicianId = (int)sessionID;
}
var model = new IncidentViewModel
{
ActiveTechnician = Context.Technicians.Find(TechnicianId),
Customers = Context.Customers.ToList(),
Products = Context.Products.ToList()
};
IQueryable <Incident> query = Context.Incidents;
query = query.Where(t => t.TechnicianID == model.ActiveTechnician.TechnicianID);
query = query.Where(t => t.DateClosed == null);
model.Incidents = query.ToList();
if (model.Incidents.Count == 0)
{
TempData["message"] = $"No Open incidents for this Technician.";
}
return(View(model));
}
}
private IncidentViewModel EditData(LocalIncident input, List <string> uploadedImages)
{
var incident = new IncidentViewModel
{
Id = input.IncidentId,
TenantId = 1,
MobileDataId = input.MobileDataId,
AnySignOfDamage = input.AnySignOfDamage,
AnySignOfObstruction = input.AnySignOfObstruction,
AreYouImpacted = input.AreYouImpacted,
FloodTypes = input.TypeOfFloodings.Select(x => new FloodTypeDto
{
TypeOfFlood = EnumHelper <TypeOfFlood> .ParseInt(x),
TenantId = 1
}).ToList(),
FloodDepth = EnumHelper <FloodDepth> .ParseInt(input.FloodDepth),
FloodExtent = EnumHelper <FloodExtent> .ParseInt(input.FloodExtent),
FrequencyOfFlood = EnumHelper <FrequencyOfFlood> .ParseInt(input.FrequencyOfFlood),
TypeOfRain = EnumHelper <TypeOfRain> .ParseInt(input.TypeOfRain),
TypesOfSpaceFlooded =
EnumHelper <TypesOfSpaceFlooded> .ParseInt(input.TypesOfSpaceFlooded),
WaterClarity = EnumHelper <WaterClarity> .ParseInt(input.WaterClarity),
Images = uploadedImages,
Date = input.Date,
LocationDtos = new List <LocationDto>
{
new LocationDto
{
TenantID = 1,
LocationType = LocationType.User,
Accuracy = input.UserLocation.Accuracy,
Longitude = input.UserLocation.Longitude,
Altitude = input.UserLocation.Altitude,
AltitudeAccuracy = input.UserLocation.AltitudeAccuracy,
Heading = input.UserLocation.Heading,
Latitude = input.UserLocation.Latitude,
Speed = input.UserLocation.Speed,
Timestamp = input.UserLocation.Timestamp.DateTime
},
new LocationDto
{
TenantID = 1,
LocationType = LocationType.Incident,
Accuracy = input.IncidentLocation.Accuracy,
Longitude = input.IncidentLocation.Longitude,
Altitude = input.IncidentLocation.Altitude,
AltitudeAccuracy = input.IncidentLocation.AltitudeAccuracy,
Heading = input.IncidentLocation.Heading,
Latitude = input.IncidentLocation.Latitude,
Speed = input.IncidentLocation.Speed,
Timestamp = input.IncidentLocation.Timestamp.DateTime
}
}
};
return(incident);
}
public IActionResult Delete(int id)
{
var incident = unitOfWork.IncidentRepository.Get(id);
IncidentViewModel vm = new IncidentViewModel {
CurrentIncident = incident, Action = "Delete"
};
return(View(vm));
}
public IActionResult Edit(int id)
{
IncidentViewModel model = new IncidentViewModel
{
Incident = data.Get(id),
Action = "Edit"
};
return(View("AddEdit", model));
}
public IActionResult Add()
{
IncidentViewModel model = new IncidentViewModel
{
Incident = new Incident(),
Action = "Add"
};
return(View("AddEdit", model));
}
public async Task <ActionResult> Create([Bind(Include = "City,Created,Description,FirstName,ImageUri,IsEmergency,LastModified,LastName,OutageType,PhoneNumber,Resolved,State,Street,ZipCode")] IncidentViewModel incident, HttpPostedFileBase imageFile)
{
try
{
if (ModelState.IsValid)
{
Incident incidentToSave = IncidentMapper.MapIncidentViewModel(incident);
using (IncidentAPIClient client = IncidentApiHelper.GetIncidentAPIClient())
{
var result = client.IncidentOperations.CreateIncident(incidentToSave);
Newtonsoft.Json.Linq.JObject jobj = (Newtonsoft.Json.Linq.JObject)result;
incidentToSave = jobj.ToObject <Incident>();
}
//TODO: ADD CODE TO UPLOAD THE BLOB
//Now upload the file if there is one
if (imageFile != null && imageFile.ContentLength > 0)
{
//### Add Blob Upload code here #####
//Give the image a unique name based on the incident id
var imageUrl = await StorageHelper.UploadFileToBlobStorage(incidentToSave.Id, imageFile);
//### Add Blob Upload code here #####
//### Add Queue code here #####
//Add a message to the queue to process this image
await StorageHelper.AddMessageToQueue(incidentToSave.Id, imageFile.FileName);
//### Add Queue code here #####
}
////##### CLEAR CACHE ####
//RedisCacheHelper.ClearCache(Settings.REDISCCACHE_KEY_INCIDENTDATA);
//##### CLEAR CACHE ####
//##### SEND EMAIL #####
await SendIncidentEmail(incidentToSave);
//##### SEND EMAIL #####
await CreateEvent(incidentToSave);
return(RedirectToAction("Index", "Dashboard"));
}
}
catch
{
return(View());
}
return(View(incident));
}
public ViewResult Add()
{
var model = new IncidentViewModel
{
Action = "Add",
Technicians = context.Technicians.OrderBy(c => c.Name).ToList(),
Customers = context.Customers.OrderBy(c => c.FirstName).ToList(),
Products = context.Products.OrderBy(p => p.Name).ToList(),
};
return(View("Edit", model));
}
public async Task <ActionResult> Create([Bind(Include = "City,Created,Description,FirstName,ImageUri,IsEmergency,LastModified,LastName,OutageType,PhoneNumber,Resolved,State,Street,ZipCode")] IncidentViewModel incident, HttpPostedFileBase imageFile)
{
try
{
if (ModelState.IsValid)
{
Incident incidentToSave = IncidentMappers.MapIncidentViewModel(incident);
using (IncidentAPIClient client = IncidentApiHelper.GetIncidentAPIClient())
{
var result = client.Incident.CreateIncident(incidentToSave);
if (!string.IsNullOrEmpty(result))
{
incidentToSave = JsonConvert.DeserializeObject <Incident>(result);
}
}
//Now upload the file if there is one
if (imageFile != null && imageFile.ContentLength > 0)
{
//### Add Blob Upload code here #####
//Give the image a unique name based on the incident id
var imageUrl = await StorageHelper.UploadFileToBlobStorage(incidentToSave.ID, imageFile);
//### Add Blob Upload code here #####
//### Add Queue code here #####
//Add a message to the queue to process this image
await StorageHelper.AddMessageToQueue(incidentToSave.ID, imageFile.FileName);
//### Add Queue code here #####
}
//##### CLEAR CACHE ####
RedisCacheHelper.ClearCache(Settings.REDISCCACHE_KEY_INCIDENTDATA);
//##### CLEAR CACHE ####
//##### SEND EMAIL #####
await SendIncidentEmail(incidentToSave, Url.Action("Index", "Dashboard", null, Request.Url.Scheme));
//##### SEND EMAIL #####
return(RedirectToAction("Index", "Dashboard"));
}
}
catch
{
return(View());
}
return(View(incident));
}
public IActionResult List(IncidentViewModel iVM)
{
var pageNumber = (iVM.Pnumber == 0) ? 1 : iVM.Pnumber;
var pageSize = 10;
var incidents = _IncidentRepository.GetByDate(iVM.Start, iVM.End).ToPagedList(pageNumber, pageSize);
iVM.Incidents = incidents;
if (TempData["editResult"] == null)
{
TempData["editResult"] = 0;
}
return(View(iVM));
}
public IActionResult Save(IncidentViewModel incidentView)
{
string successMessage;
if (ModelState.IsValid)
{
if (incidentView.Action == "Add")
{
context.Incidents.Add(incidentView.Incident);
successMessage = incidentView.Incident.Title + " was added.";
}
else
{
context.Incidents.Update(incidentView.Incident);
successMessage = incidentView.Incident.Title + " was updated.";
}
context.SaveChanges();
TempData["message"] = successMessage;
return(RedirectToAction("List"));
}
else
{
//StoreListsInViewBag();
IncidentViewModel model = new IncidentViewModel();
var incident = context.Incidents.Find(incidentView.Incident.IncidentID);
model.Incident = incident;
if (incidentView.Action == "Add")
{
model.Action = "Add";
//ViewBag.Action = "Add";
}
else
{
model.Action = "Edit";
//ViewBag.Action = "Edit";
}
model.Customers = context.Customers
.OrderBy(c => c.FirstName)
.ToList();
model.Products = context.Products
.OrderBy(p => p.Name)
.ToList();
model.Technicians = context.Technicians
.OrderBy(t => t.Name)
.ToList();
return(View("AddEdit", model));
}
}
public ViewResult Edit(int id)
{
var t = context.Incidents.Find(id);
var viewModel = new IncidentViewModel
{
CurrentIncident = t,
Customers = context.Customers.OrderBy(c => c.FirstName).ToList(),
Products = context.Products.OrderBy(p => p.Name).ToList(),
Technicians = context.Technicians.OrderBy(c => c.Name).ToList(),
Action = "Edit"
};
return(View("Edit", viewModel));
}
public ActionResult Details(string Id)
{
IncidentViewModel incidentView = null;
using (IncidentAPIClient client = IncidentApiHelper.GetIncidentAPIClient())
{
var result = client.IncidentOperations.GetById(Id);
Newtonsoft.Json.Linq.JObject jobj = (Newtonsoft.Json.Linq.JObject)result;
Incident incident = jobj.ToObject <Incident>();
incidentView = IncidentMapper.MapIncidentModelToView(incident);
}
return(View(incidentView));
}
private Incident IncidentViewModelToIncident(Incident incident, IncidentViewModel model)
{
incident.IncidentStatusId = (int)IncidentStatusesEnum.New; // 1 - New
incident.Title = model.Title;
incident.Description = model.Description;
incident.Adress = model.Adress;
incident.Latitude = model.Lat;
incident.Longitude = model.Lng;
incident.PriorityId = (int)IncidentPrioritiesEnum.Zero;
incident.UserId = _userHelper.GetUserId();
return(incident);
}
