public ActionResult WarrantyForm()
{
var repairViewModel = new RepairViewModel();
repairViewModel.RepairItems.Add(new RepairItemViewModel());
return(View(repairViewModel));
}
GetAllRepairs(string serviceName)
{
ConnectionConfig config = new ConnectionConfig();
FirestoreDb db = config.GetFirestoreDb();
List <RepairViewModel> repairs = new List <RepairViewModel>();
string docId = GetDocumentId(
"service-repairs", serviceName).Result;
Query query = db.Collection("service-repairs")
.Document(docId)
.Collection("repairs");
QuerySnapshot snapshot = await query.GetSnapshotAsync();
Parallel.ForEach(snapshot.Documents, ds => {
if (ds.Exists)
{
RepairViewModel model = NewModel(ds);
repairs.Add(model);
}
});
return(repairs
.OrderBy(x => x.RepairId)
.ToList());
}
private Repair NewRepair(RepairViewModel model)
{
return(new Repair()
{
RepairId = model.RepairId,
RepairStatus = model.RepairStatus,
CreatedAt = model.CreatedAt,
CustomerName = model.CustomerName,
CustomerAddress = model.CustomerAddress,
CustomerPhoneNumber = model.CustomerPhoneNumber,
DefectByCustomer = model.DefectByCustomer,
GoingToAddress = model.GoingToAddress,
InWarranty = model.InWarranty,
ApplianceBrand = model.ApplianceBrand,
ApplianceType = model.ApplianceType,
ApplianceModel = model.ApplianceModel,
ApplianceSerialNumber = model.ApplianceSerialNumber,
ApplianceProductCodeOrImei = model.ApplianceProductCodeOrImei,
ApplianceEquipment = model.ApplianceEquipment,
BoughtFrom = model.BoughtFrom,
WarrantyCardNumber = model.WarrantyCardNumber,
WarrantyPeriod = model.WarrantyPeriod,
BoughtAt = model.BoughtAt,
AdditionalInformation = model.AdditionalInformation
});
}
public async Task <IActionResult> Index()
{
var currentUser = await userManager.GetUserAsync(HttpContext.User);
var user = await userDataService.GetCurrentUserWithItemsAndRobotsAsync(currentUser);
if (user == null)
{
return(NotFound());
}
var robots = user.Robots.Where(r => r.CurrentHealth != r.BaseHealth).ToList();
var weapons = user.Weapons.Where(w => w.Durability != 100).ToList();
var armors = user.Armors.Where(a => a.Durability != 100).ToList();
var robotsViewModel = Mapper.Map <IEnumerable <RobotRepairViewModel> >(robots);
var weaponsViewModel = Mapper.Map <IEnumerable <WeaponRepairViewModel> >(weapons);
var armorsViewModel = Mapper.Map <IEnumerable <ArmorRepairViewModel> >(armors);
var repairModel = new RepairViewModel()
{
RobotsViewModel = robotsViewModel,
WeaponsViewModel = weaponsViewModel,
ArmorsViewModel = armorsViewModel
};
return(this.View(repairModel));
}
GetAllRepairs(string serviceName)
{
ConnectionConfig config = new ConnectionConfig();
FirestoreDb db = config.GetFirestoreDb();
List <RepairViewModel> repairs = new List <RepairViewModel>();
QuerySnapshot snapshot = await db
.Collection("service-repairs")
.GetSnapshotAsync();
Parallel.ForEach(snapshot.Documents, ds => {
lock (typeof(Repair)) {
if (ds.Exists)
{
RepairViewModel model = NewModel(ds);
repairs.Add(model);
}
}
});
return(repairs
.OrderBy(x => x.RepairId)
.ToList());
}
public async Task <List <RepairViewModel> > RepairList(int PropertyId)
{
List <RepairList> repair = await _repairRepository.RepairList(PropertyId);
List <RepairViewModel> repairVM = new List <RepairViewModel>();
foreach (RepairList r in repair)
{
RepairViewModel rVM = new RepairViewModel();
rVM.PropertyId = r.PropertyId;
rVM.UrgencyName = r.UrgencyName;
rVM.RequestTypeName = r.RequestTypeName;
rVM.RepairId = r.RepairId;
rVM.ServiceCategoryName = r.ServiceCategoryName;
rVM.Description = r.Description;
rVM.RepairReportedDate = r.RepairReportedDate;
rVM.RepairCompletedDate = r.RepairCompletedDate;
rVM.TechnicianName = r.TechnicianName;
rVM.RepairCost = Convert.ToDecimal(string.Format("{0:0.00}", r.RepairCost));
rVM.Notes = r.Notes;
rVM.StatusName = r.StatusName;
rVM.PaymentTypeName = r.PaymentTypeName;
rVM.RepairId = r.RepairId;
repairVM.Add(rVM);
}
return(repairVM);
}
public IActionResult Schedule(RepairViewModel model)
{
if (ModelState.IsValid)
{
var schedule = new Schedule
{
CarId = model.Cars.CarId,
DateId = model.Cars.CarId,
Date = model.Schedule.Date,
RepairType = model.RepairType.RepairTypeName
};
int tableLength = _context.Schedule.ToList().Count();
if (tableLength < 5)
{
_context.Schedule.Add(schedule);
_context.SaveChanges();
TempData["Operation"] = "Repair Registration Successful.";
return(RedirectToAction("Index", "Home", TempData));
}
else
{
TempData["Operation"] = "Workshop currently full, come back another day.";
return(RedirectToAction("Index", "Home", TempData));
}
}
return(View(model));
}
public async Task <ResponseMessage <long> > PostReportForPair([FromBody] RepairViewModel model)
{
if (ModelState.IsValid)
{
string jti = HttpContext.User.FindFirst(x => x.Type == JwtRegisteredClaimNames.Jti).Value;
long id = await _reportForRepairService.Add(new ReportForRepair()
{
UserId = Convert.ToInt64(jti),
Layer = model.Layer,
Tung = model.Tung,
Dorm = model.Dorm,
Desc = model.Desc
});
return(new ResponseMessage <long>()
{
Msg = "报修已提交",
Status = 200,
Success = true,
ResponseInfo = id
});
}
return(new ResponseMessage <long>()
{
Msg = "填写信息不完全",
Success = false
});
}
public async Task <IActionResult> Edit(RepairViewModel vmodel)
{
if (ModelState.IsValid)
{
try
{
var repair = _converterHelper.ToRepair(vmodel);
repair.AppointmentId = vmodel.AppointmentId;
await _repairRepository.UpdateAsync(repair);
}
catch (DbUpdateConcurrencyException)
{
if (!await _repairRepository.ExistAsync(vmodel.Id))
{
return(NotFound());
}
else
{
throw;
}
}
if (User.IsInRole("Mechanic"))
{
return(RedirectToAction("MyRepairs", "Mechanics"));
}
return(RedirectToAction(nameof(Index)));
}
return(View(vmodel));
}
public Task DiagnoseAndRepairSynqRepository()
{
var vm = new RepairViewModel();
vm.ProcessCommand.Execute(null);
return(_specialDialogManager.ShowDialog(vm));
}
public IActionResult Remove()
{
RepairViewModel model = new RepairViewModel();
model.ScheduleList = _context.Schedule.ToList();
return(View(model));
}
public async Task <IActionResult> Repair(RepairViewModel repairLoan)
{
string insertToRepairs = "Insert into Repairs values (" + repairLoan.InstrumentInventoryId.ToString() + ", (select top 1 [Technician ID] from Technician), GETDATE(), '" + repairLoan.Notes + "' , null)";
var repairResult = _context.Database.ExecuteSqlCommand(insertToRepairs);
//Give out new loan
string proc = "[Loan Instrument] " + repairLoan.EnrollmentId.ToString();
var loanResult = _context.Database.ExecuteSqlCommand(proc);
//Return loan
var loan = await _context.Loan
.Include(l => l.Enrollment)
.Include(l => l.InstrumentInventory)
.FirstOrDefaultAsync(m => m.EnrollmentId == repairLoan.EnrollmentId &&
m.InstrumentInventoryId == repairLoan.InstrumentInventoryId &&
m.DateReturned == null);
loan.DateReturned = DateTime.Today;
string feedbackString = REPAIR_SUCCESS;
string colorString = "green";
if (loanResult < 1)
{
feedbackString = LOAN_ERROR;
colorString = "red";
}
else if (repairResult < 1)
{
feedbackString = REPAIR_ERROR;
colorString = "red";
}
if (ModelState.IsValid)
{
try
{
_context.Update(loan);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!LoanExists(loan.InstrumentInventoryId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction("Feedback", new { feedback = feedbackString, color = colorString }));
}
return(RedirectToAction("Feedback", new { feedback = feedbackString, color = colorString }));
}
// Method för gathering/creating dates.
public RepairViewModel getScheduleList()
{
RepairViewModel model = new RepairViewModel();
string sql = $"SELECT * FROM Schedule";
DBManager dbm = new DBManager(sql);
DataTable tbl = dbm.ExecuteSQL();
List <DateTime> dateList = new List <DateTime>();
foreach (DataRow row in tbl.Rows)
{
dateList.Add((DateTime)row["Date"]);
}
for (int i = 0; i < 5; i++)
{
// Date 25 & under.
if (DateTime.Now.Day <= 25)
{
DateTime date = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day + i + 1, 09, 00, 00);
Schedule temp = new Schedule(i, date);
if (!dateList.Contains(date))
{
model.ScheduleList.Add(temp);
}
}
// Date over 25.
else
{
// Current month contains 30 days.
if (DateTime.DaysInMonth(DateTime.Now.Year, DateTime.Now.Month) == 30)
{
DateTime date = new DateTime(DateTime.Now.Year, DateTime.Now.Month + 1, DateTime.Now.Day - DateTime.Now.Day + i + 1, 09, 00, 00);
var temp = new Schedule(i, date);
if (!dateList.Contains(date))
{
model.ScheduleList.Add(temp);
}
}
// Current month contains 31 days.
else if (DateTime.DaysInMonth(DateTime.Now.Year, DateTime.Now.Month) == 31)
{
DateTime date = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day + i + 6, 09, 00, 00);
var temp = new Schedule(i, date);
if (!dateList.Contains(date))
{
model.ScheduleList.Add(temp);
}
}
}
}
return(model);
}
public IActionResult Details(string id)
{
RepairViewModel repair = new RepairViewModel()
{
Repair = _unitOfWork.Repair.GetFirstOrDefault(x => x.Id == id, includeProperties: "Status,Mark,RepairCost,Address,DeviceType")
};
return(View(repair));
}
public IActionResult RepairCost(string id)
{
RepairViewModel repair = new RepairViewModel()
{
Repair = _unitOfWork.Repair.GetFirstOrDefault(x => x.Id == id, includeProperties: "RepairCost")
};
return(View(repair));
}
public IActionResult Remove(RepairViewModel model)
{
string sql = $"Delete Schedule FROM Schedule WHERE Date = '{ model.Schedule.Date }'";
DBManager dbm = new DBManager(sql);
dbm.ExecuteSQLNoReturn();
TempData["Operation"] = "Appointment Successfully Removed.";
return(RedirectToAction("Index", "Home", TempData));
}
public Repair ToRepair(RepairViewModel model)
{
return(new Repair
{
Id = model.Id,
RepairInfo = model.RepairInfo,
CompletedAt = model.CompletedAt,
AppointmentId = model.AppointmentId,
Appointment = model.Appointment
});
}
public IActionResult RepairCost(string id)
{
var repairCostId = _unitOfWork.Repair.GetFirstOrDefault(x => x.Id == id).RepairCostId;
RepairViewModel repair = new RepairViewModel()
{
Repair = _unitOfWork.Repair.GetFirstOrDefault(x => x.Id == id),
RepairCost = _unitOfWork.RepairCost.GetFirstOrDefault(x => x.Id == repairCostId)
};
return(View(repair));
}
public IActionResult Schedule()
{
RepairViewModel model = getScheduleList();
model.CarList = _context.Cars.ToList();
model.RepairTypeList.Add(new RepairType(1, "Service"));
model.RepairTypeList.Add(new RepairType(2, "Repair"));
model.RepairTypeList.Add(new RepairType(3, "Other"));
return(View(model));
}
public IActionResult Manage(string?id)
{
RepairViewModel = new RepairViewModel()
{
DeviceType = new Models.DeviceType()
};
if (id != null)
{
RepairViewModel.DeviceType = _unitOfWork.DeviceType.Get(id);
}
return(View(RepairViewModel));
}
public async void UpdateRepair(RepairViewModel model)
{
FirestoreDb db = connection.GetFirestoreDb();
QuerySnapshot snapshot = db
.Collection("service-repairs")
.WhereEqualTo("RepairId", model.RepairId)
.Limit(1)
.GetSnapshotAsync()
.Result;
Repair repair = snapshot
.FirstOrDefault()
.ConvertTo <Repair>();
repair = NewRepair(model);
repair.Notes = model.Notes;
Dictionary <string, object> d = repair
.GetType()
.GetProperties()
.ToDictionary(x => x.Name, x => x.GetValue(repair, null));
string logDesc = "Update repair card";
await snapshot.Documents
.FirstOrDefault()
.Reference
.UpdateAsync(d);
//modelAsDict
// .ToList()
// .ForEach(x => {
// if(repairAsDict.ContainsKey(x.Key)) {
// if(repairAsDict[x.Key] != x.Value) {
// logDesc += $"\\n{x.Key} from {repairAsDict[x.Key]} to {x.Value}";
// }
// }
// });
RepairLog log = new RepairLog()
{
TimeOfEvent = DateTime.UtcNow,
Description = logDesc,
TypeOfEvent = "update"
};
await new LogService()
.UploadLogToExistingRepair(model.RepairId, log);
}
public IActionResult Manage(string?id)
{
RepairViewModel = new RepairViewModel()
{
Mark = new Models.Mark()
};
if (id != null)
{
RepairViewModel.Mark = _unitOfWork.Mark.Get(id);
}
return(View(RepairViewModel));
}
private RepairViewModel NewModel(DocumentSnapshot ds)
{
RepairViewModel result = new RepairViewModel();
ds.ToDictionary()
.ToList()
.ForEach(keyVal => {
result
.GetType()
.GetProperty(keyVal.Key)
.SetValue(result, keyVal.Value);
});
return(result);
}
public AddNoteView(RepairViewModel repair)
{
InitializeComponent();
var vm = new AddNoteViewModel(repair);
this.DataContext = vm;
if (vm.CloseAction == null)
{
vm.CloseAction = new Action(() => this.Close());
}
if (vm.RefreshAction == null)
{
vm.RefreshAction = new Action(() => MainWindowViewModel.Instance.RefreshRepairs());
}
}
public IActionResult Create()
{
DateTime now = DateTime.Now;
RepairViewModel = new RepairViewModel()
{
Repair = new Models.Repair(),
Address = new Models.Address(),
RepairCost = new Models.RepairCost(),
MarkList = _unitOfWork.Mark.GetMarkListFromDropDown(),
DeviceTypeList = _unitOfWork.DeviceType.GetDeviceTypeListFromDropDown()
};
RepairViewModel.Repair.PickupDate = now;
return(View(RepairViewModel));
}
public void ConfirmRepairEdit(int faultId, int repairId, string repairState, DateTime?startDate,
DateTime?finishDate, DateTime?commissionDate, string companyNip)
{
int?companyId = companyService.GetSingleCompany(companyNip)?.id_firmy;
var newRepair = new RepairViewModel()
{
id_usterki = faultId,
id_firmy = companyId,
stan = repairState,
data_rozpoczecia = startDate,
data_ukonczenia = finishDate,
data_zlecenia = commissionDate,
id_naprawy = repairId
};
repairsService.AddOrEditRepair(ViewModelMapper.Mapper.Map <RepairModel>(newRepair));
}
public async Task <IActionResult> AddEditRepair(int RepairId = 0, int PropertyId = 0)
{
try
{
var property = await this._propertyService.PropertyById(PropertyId);
ViewBag.PropertyInformation = property.Address + " - " + property.City;
if (RepairId > 0)
{
int StatusTypeId = 2;
var query = await this._repairService.RepairById(RepairId);
UrgencyTypeDropDownList("UrgencyId", "UrgencyName", query.UrgencyId);
ServiceCategoryTypeDropDownList("ServiceCategoryId", "ServiceCategoryName", query.ServiceCategoryId);
ProfessionalServiceTypeDropDownList("ProfessionalServiceId", "CompanyName", query.ProfessionalServiceId);
RequestTypeDropDownList("RequestTypeId", "RequestTypeName", query.RequestTypeId);
PaymentMethodTypeDropDownList("PaymentMethodId", "PaymentMethodName", query.PaymentTypeId);
StatusDropDownList("StatusId", "StatusName", query.StatusId, StatusTypeId);
ViewBag.TableTitle = "Edit Repair Information";
return(PartialView(query));
}
else
{
UrgencyTypeDropDownList("UrgencyId", "UrgencyName", 0);
ServiceCategoryTypeDropDownList("ServiceCategoryId", "ServiceCategoryName", 0);
ProfessionalServiceTypeDropDownList("ProfessionalServiceId", "CompanyName", 0);
RequestTypeDropDownList("RequestTypeId", "RequestTypeName", 0);
PaymentMethodTypeDropDownList("PaymentMethodId", "PaymentMethodName", 0);
ViewBag.TableTitle = "Add Repair Information";
RepairViewModel rVM = new RepairViewModel();
rVM.RepairId = RepairId;
rVM.PropertyId = PropertyId;
return(PartialView(rVM));
}
}
catch (SqlException ex)
{
var errorMessage = ex.Message;
return(Content(errorMessage.ToString(), "text/plain"));
}
}
public async Task <ActionResult <RepairViewModel> > NewRepairAsync([FromBody] RepairViewModel repairViewModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Repair repair = new Repair {
CustomerID = repairViewModel.CustomerID,
DeviceID = repairViewModel.DeviceID,
ProblemDescription = repairViewModel.ProblemDescription,
RequestDate = DateTime.Now,
Cancelled = false,
StatusID = 1//New request
};
var result = await _repairService.NewRepair(repair);
return(_mapper.Map <RepairViewModel>(repair));
}
// GET: Repairs/Create
public IActionResult Create()
{
if (User.IsInRole("Mechanic"))
{
var model = new RepairViewModel
{
Appointments = _appointmentRepository.GetComboUserAppointment(User.Identity.Name)
};
return(View(model));
}
else
{
var model = new RepairViewModel
{
Appointments = _appointmentRepository.GetComboAppointment()
};
return(View(model));
}
}
public async Task <RepairViewModel> RepairById(int RepairId)
{
var r = await _repairRepository.RepairById(RepairId);
RepairViewModel rVM = new RepairViewModel();
rVM.RepairId = r.RepairId;
rVM.PropertyId = r.PropertyId;
rVM.UrgencyId = r.UrgencyId;
rVM.RequestTypeId = r.RequestTypeId;
rVM.ServiceCategoryId = r.ServiceCategoryId;
rVM.ProfessionalServiceId = r.ProfessionalServiceId;
rVM.Description = r.Description;
rVM.RepairReportedDate = r.RepairReportedDate;
rVM.RepairCompletedDate = r.RepairCompletedDate;
rVM.TechnicianName = r.TechnicianName;
rVM.RepairCost = r.RepairCost;
rVM.PaymentTypeId = r.PaymentTypeId;
rVM.Notes = r.Notes;
rVM.StatusId = r.StatusId;
return(rVM);
}
public ActionResult UpdateStatus(int id, RepairViewModel model)
{
var repairOrder = this.InOrdersServices.GetById(id);
if (repairOrder == null)
{
return this.View("Error");
}
repairOrder.Status = model.Status;
this.InOrdersServices.UpdateStatus(id, repairOrder);
var content = model.Status;
return this.Content(content.ToString());
}
