public async Task <IActionResult> PayRepair(string repairId)
{
try
{
ViewBag.Role = await InitRole();
var repairMksResult = JsonConvert.DeserializeObject <MksResponseResult>(
await RequestExecutor.ExecuteRequest(Scope.RepairsMksUrl,
new RestRequest("/TryToPayOrder", Method.POST)
.AddHeader("Content-type", "application/json")
.AddJsonBody(JsonConvert.SerializeObject(new PayOrderModel
{
RepairId = long.Parse(repairId),
}))));
if (!repairMksResult.Success)
{
throw new Exception(repairMksResult.Data);
}
return(Json(
new
{
Success = true,
repairMksResult.Data
}));
}
catch (Exception exception)
{
return(Json(new { Success = false, exception.Message }));
}
}
internal ICompletes <Response> Execute(Request request, T param1, TR param2, TU param3, TI param4, TJ param5, TK param6, ILogger logger)
{
Func <ICompletes <Response> > exec = ()
=> _executor?.Invoke(request, param1, param2, param3, param4, param5, param6, MediaTypeMapper, ErrorHandler, logger) !;
return(RunParamExecutor(_executor, () => RequestExecutor.ExecuteRequest(exec, ErrorHandler, logger)));
}
public async Task <IActionResult> RemoveEquipment(int equipmentId)
{
try
{
ViewBag.Role = await InitRole();
var equipmentMksResult = JsonConvert.DeserializeObject <MksResponseResult>(
await RequestExecutor.ExecuteRequest(Scope.EquipmentMksUrl,
new RestRequest("/RemoveEquipment", Method.POST)
.AddHeader("Content-type", "application/json")
.AddJsonBody(new
{
equipmentId
})));
if (!equipmentMksResult.Success)
{
throw new Exception(equipmentMksResult.Data);
}
return(RedirectToAction("Index", "Equipment"));
}
catch (Exception exception)
{
ModelState.AddModelError(nameof(exception), exception.ToString());
throw;
}
}
public async Task <IActionResult> Index()
{
try
{
var identity = (ClaimsIdentity)User.Identity;
var _userPhoneNumber = identity.Claims.ToList()[0].Value;
var person = await _personsRepository.GetPersonByPhoneNumber(_userPhoneNumber);
var equipments = new List <EquipmentInfo>();
if (person.Role == (byte)PersonTypes.Client)
{
var equipmentMksResult = JsonConvert.DeserializeObject <MksResponseResult>(
await RequestExecutor.ExecuteRequest(Scope.EquipmentMksUrl,
new RestRequest("/SearchEquipmentsByPerson", Method.POST)
.AddHeader("Content-type", "application/json")
.AddParameter(new Parameter("personId", person.PersonId, ParameterType.RequestBody))));
equipments = JsonConvert.DeserializeObject <IEnumerable <EquipmentInfo> >(equipmentMksResult.Data).ToList();
}
else
{
var equipmentMksResult = JsonConvert.DeserializeObject <MksResponseResult>(
await RequestExecutor.ExecuteRequest(Scope.EquipmentMksUrl,
new RestRequest("/GetAllEquipments", Method.GET)
.AddHeader("Content-type", "application/json")
));
equipments = JsonConvert.DeserializeObject <IEnumerable <EquipmentInfo> >(equipmentMksResult.Data).ToList();
}
ViewBag.Role = (PersonTypes)person.Role;
return(View(equipments));
}
catch
{
return(RedirectToAction("Index", "Home"));
}
}
public async Task <IActionResult> Index()
{
try
{
var repairs = new List <RepairInfo>();
var identity = (ClaimsIdentity)User.Identity;
var userPhoneNumber = identity.Claims.ToList()[0].Value;
var person = await _personsRepository.GetPersonByPhoneNumber(userPhoneNumber);
if (person.Role == (byte)PersonTypes.Administator)
{
var repairMksResult = JsonConvert.DeserializeObject <MksResponseResult>(
await RequestExecutor.ExecuteRequest(Scope.RepairsMksUrl,
new RestRequest("/GetAllRepairs/", Method.GET)
.AddHeader("Content-type", "application/json")));
repairs = JsonConvert.DeserializeObject <IEnumerable <RepairInfo> >(repairMksResult.Data).ToList();
}
else
{
return(RedirectToAction("Index", "Home"));
}
ViewBag.Role = (PersonTypes)person.Role;
ViewBag.TotalCost = repairs.Sum(x => x.Cost);
return(View(repairs));
}
catch (Exception)
{
return(RedirectToAction("Index", "Home"));
}
}
internal ICompletes <Response> Execute(Request request, ILogger logger)
{
Func <ICompletes <Response> > exec = ()
=> _executor?.Invoke(request, MediaTypeMapper, ErrorHandler, logger) !;
return(RunParamExecutor(_executor, () => RequestExecutor.ExecuteRequest(exec, ErrorHandler, logger)));
}
public async Task <IActionResult> AddRepair(RepairParamModel model)
{
try
{
if (!Enum.TryParse(model.EType, out EquipmentTypes equipmentType))
{
equipmentType = EquipmentTypes.OtherDevice;
}
if (!Enum.TryParse(model.RType, out RepairTypes repairType))
{
repairType = RepairTypes.FirstOfAll;
}
var identity = (ClaimsIdentity)User.Identity;
var userPhoneNumber = identity.Claims.ToList()[0].Value;
var person = await _personsRepository.GetPersonByPhoneNumber(userPhoneNumber);
if (person.Role == (byte)PersonTypes.Administator)
{
person.Fio = model.Client;
}
ViewBag.Role = (PersonTypes)person.Role;
var repairMksResult = JsonConvert.DeserializeObject <MksResponseResult>(
await RequestExecutor.ExecuteRequest(Scope.RepairsMksUrl,
new RestRequest("/RepairApplication", Method.POST)
.AddHeader("Content-type", "application/json")
.AddJsonBody(JsonConvert.SerializeObject(new RepairApplicationModel
{
ClientFIO = person.Fio,
MasterFIO = "не определен",
RepairType = (byte)repairType,
StartDate = DateTime.UtcNow,
EndDate = default(DateTime)
}))));
if (!repairMksResult.Success)
{
throw new Exception(repairMksResult.Data);
}
var equipmentMksResult = JsonConvert.DeserializeObject <MksResponseResult>(
await RequestExecutor.ExecuteRequest(Scope.EquipmentMksUrl,
new RestRequest("/CreateEquipment", Method.POST)
.AddHeader("Content-type", "application/json")
.AddJsonBody(JsonConvert.SerializeObject(new EquipmentParamModel
{
Name = model.EquipmentName,
RepairId = long.Parse(repairMksResult.Data),
EquipmentType = (byte)equipmentType,
Defects = new List <EquipmentInfoParamModel>()
}))));
if (!equipmentMksResult.Success)
{
throw new Exception(equipmentMksResult.Data);
}
return(RedirectToAction("Index", "Equipment"));
}
catch (Exception exception)
{
ModelState.AddModelError(nameof(exception), exception.ToString());
throw;
}
}
public async Task <IActionResult> UpdateMaster(RepairWithMasterModel model)
{
try
{
ViewBag.Role = await InitRole();
var repairMksResult = JsonConvert.DeserializeObject <MksResponseResult>(
await RequestExecutor.ExecuteRequest(Scope.RepairsMksUrl,
new RestRequest("/UpdateRepairMaster", Method.POST)
.AddHeader("Content-type", "application/json")
.AddJsonBody(JsonConvert.SerializeObject(model))));
if (!repairMksResult.Success)
{
throw new Exception(repairMksResult.Data);
}
return(Json(
new
{
Success = true,
Data = "ok"
}));
}
catch (Exception exception)
{
return(Json(new { Success = false, exception.Message }));
}
}
public async Task <long> RepairApplication(RepairApplicationModel repairModel)
{
var personMksResultWithClient = JsonConvert.DeserializeObject <MksResponseResult>(
await RequestExecutor.ExecuteRequest(Scope.PersonMksUrl,
new RestRequest("/GetPersonIdByFIO", Method.POST)
.AddHeader("Content-type", "application/json")
.AddJsonBody(new
{
fio = repairModel.ClientFIO
})));
if (!personMksResultWithClient.Success)
{
throw new Exception(personMksResultWithClient.Data);
}
MksResponseResult result;
long?master = null;
if (repairModel.MasterFIO != "не определен")
{
result = JsonConvert.DeserializeObject <MksResponseResult>(
await RequestExecutor.ExecuteRequest(Scope.PersonMksUrl,
new RestRequest("/GetPersonIdByFIO", Method.POST)
.AddHeader("Content-type", "application/json")
.AddJsonBody(new
{
fio = repairModel.MasterFIO
})));
if (!result.Success)
{
throw new Exception(result.Data);
}
master = long.Parse(result.Data);
}
var repair = new Models.Repairs
{
StartDate = repairModel.StartDate,
EndDate = repairModel.EndDate,
RepairType = repairModel.RepairType,
Status = (byte)RepairStatuses.Confirm,
Client = long.Parse(personMksResultWithClient.Data),
Master = master
};
_context.Repairs.Add(repair);
await _context.SaveChangesAsync();
return(repair.RepairId);
}
public async Task <IEnumerable <EquipmentInfo> > SearchEquipmentsByPerson(long personId)
{
var repairMksResult = JsonConvert.DeserializeObject <MksResponseResult>(
await RequestExecutor.ExecuteRequest(Scope.RepairsMksUrl,
new RestRequest("/GetRepairsById", Method.POST)
.AddHeader("Content-type", "application/json")
.AddParameter(new Parameter("personId", personId, ParameterType.RequestBody))));
if (!repairMksResult.Success)
{
throw new Exception(repairMksResult.Data);
}
var repairs = JsonConvert.DeserializeObject <IEnumerable <RepairInfo> >(repairMksResult.Data).ToList();
var result = new List <EquipmentInfo>();
foreach (var repair in repairs)
{
var equips = _context.Equipments.Where(x => x.RepairId == repair.RepairId);
foreach (var equip in equips)
{
var equipmentInfo = new EquipmentInfo
{
EquipmentId = equip.EquipmentId,
EquipmentType = (EquipmentTypes)equip.EquipmentType,
Name = equip.Name,
Repair = equip.RepairId
};
var defects = _context.EquipmentDefects.Where(x => x.EquipmentId == equip.EquipmentId);
if (defects != null)
{
equipmentInfo.Defects = await defects.Select(x => new EquipmentDefectsModel
{
DefectId = x.DefectId,
DefectName = x.DefectName,
EquipmentId = x.EquipmentId,
Price = x.Price
}).ToListAsync();
}
result.Add(equipmentInfo);
}
if (!result.Any())
{
throw new Exception("Equipments not found");
}
}
return(result);
}
public async Task <IActionResult> ChangeRepairStatus(RepairStatusParamModel model)
{
try
{
ViewBag.Role = await InitRole();
if (!Enum.TryParse(model.Status, out RepairStatuses repairStatus))
{
throw new Exception("Parsing error");
}
if (repairStatus == RepairStatuses.Cancel)
{
var repairMksResult2 = JsonConvert.DeserializeObject <MksResponseResult>(
await RequestExecutor.ExecuteRequest(Scope.RepairsMksUrl,
new RestRequest("/RemoveRepair", Method.GET)
.AddHeader("Content-type", "application/json")
.AddParameter(new Parameter("repairId", long.Parse(model.RepairId), ParameterType.GetOrPost))));
if (!repairMksResult2.Success)
{
throw new Exception(repairMksResult2.Data);
}
}
var repairMksResult = JsonConvert.DeserializeObject <MksResponseResult>(
await RequestExecutor.ExecuteRequest(Scope.RepairsMksUrl,
new RestRequest("/ChangeRepairStatus", Method.POST)
.AddHeader("Content-type", "application/json")
.AddJsonBody(JsonConvert.SerializeObject(new RepairStatusModel
{
RepairId = long.Parse(model.RepairId),
Status = (byte)repairStatus
}))));
if (!repairMksResult.Success)
{
throw new Exception(repairMksResult.Data);
}
return(Json(
new
{
Success = true,
Data = "ok"
}));
}
catch (Exception exception)
{
return(Json(new { Success = false, exception.Message }));
}
}
public async Task <IActionResult> CheckAvailible(string repairId)
{
var repairMksResult = JsonConvert.DeserializeObject <MksResponseResult>(
await RequestExecutor.ExecuteRequest(Scope.RepairsMksUrl,
new RestRequest("/GetRepairReport", Method.POST)
.AddHeader("Content-type", "application/json")
.AddParameter(new Parameter("repairId", long.Parse(repairId), ParameterType.RequestBody))));
if (!repairMksResult.Success)
{
throw new Exception(repairMksResult.Data);
}
var repair = JsonConvert.DeserializeObject <RepairInfo>(repairMksResult.Data);
return(Json(new { Availible = repair.Status == RepairStatuses.Diagnostic }));
}
public async Task <IActionResult> RepairList()
{
try
{
var repairs = new List <RepairInfo>();
var identity = (ClaimsIdentity)User.Identity;
var userPhoneNumber = identity.Claims.ToList()[0].Value;
var person = await _personsRepository.GetPersonByPhoneNumber(userPhoneNumber);
if (person.Role == (byte)PersonTypes.Master)
{
var repairMksResult = JsonConvert.DeserializeObject <MksResponseResult>(
await RequestExecutor.ExecuteRequest(Scope.RepairsMksUrl,
new RestRequest("/GetRepairsByMasterId", Method.POST)
.AddHeader("Content-type", "application/json")
.AddParameter(new Parameter("personId", person.PersonId, ParameterType.RequestBody))));
repairs = JsonConvert.DeserializeObject <IEnumerable <RepairInfo> >(repairMksResult.Data).ToList();
}
else if (person.Role == (byte)PersonTypes.Administator)
{
var repairMksResult = JsonConvert.DeserializeObject <MksResponseResult>(
await RequestExecutor.ExecuteRequest(Scope.RepairsMksUrl,
new RestRequest("/GetAllRepairs/", Method.GET)
.AddHeader("Content-type", "application/json")));
repairs = JsonConvert.DeserializeObject <IEnumerable <RepairInfo> >(repairMksResult.Data).ToList();
}
else
{
var repairMksResult = JsonConvert.DeserializeObject <MksResponseResult>(
await RequestExecutor.ExecuteRequest(Scope.RepairsMksUrl,
new RestRequest("/GetRepairsById", Method.POST)
.AddHeader("Content-type", "application/json")
.AddParameter(new Parameter("personId", person.PersonId, ParameterType.RequestBody))));
repairs = JsonConvert.DeserializeObject <IEnumerable <RepairInfo> >(repairMksResult.Data).ToList();
}
var persons = await _personsRepository.GetPersons();
ViewBag.Clients = persons.Where(x => x.Role == (byte)PersonTypes.Client).Select(x => x.Fio);
ViewBag.Masters = persons.Where(x => x.Role == (byte)PersonTypes.Master).Select(x => x.Fio);
ViewBag.Role = (PersonTypes)person.Role;
return(View(repairs));
}
catch (Exception)
{
return(RedirectToAction("Index", "Home"));
}
}
public async Task <IActionResult> RepairDetails(string repairId)
{
ViewBag.Role = await InitRole();
var result = new RepairInfo();
var repairMksResult = JsonConvert.DeserializeObject <MksResponseResult>(
await RequestExecutor.ExecuteRequest(Scope.RepairsMksUrl,
new RestRequest("/GetRepairReport", Method.POST)
.AddHeader("Content-type", "application/json")
.AddParameter(new Parameter("repairId", long.Parse(repairId), ParameterType.RequestBody))));
if (!repairMksResult.Success)
{
throw new Exception(repairMksResult.Data);
}
else
{
result = JsonConvert.DeserializeObject <RepairInfo>(repairMksResult.Data);
}
return(View("_RepairDetails", result));
}
public async Task RemoveRepair(long repairId)
{
var repair = await _context.Repairs.FirstOrDefaultAsync(x => x.RepairId == repairId);
if (repair == null)
{
throw new Exception("Repair not found");
}
var equipmentMksResult = JsonConvert.DeserializeObject <MksResponseResult>(
await RequestExecutor.ExecuteRequest(Scope.EquipmentMksUrl,
new RestRequest("/SearchEquipmentsByRepair", Method.POST)
.AddHeader("Content-type", "application/json")
.AddParameter(new Parameter("repairId", repairId, ParameterType.RequestBody))));
if (!equipmentMksResult.Success)
{
throw new Exception(equipmentMksResult.Data);
}
var equipmentsInfo = JsonConvert.DeserializeObject <IEnumerable <EquipmentInfo> >(equipmentMksResult.Data);
foreach (var equip in equipmentsInfo)
{
var equipmentMksResult2 = JsonConvert.DeserializeObject <MksResponseResult>(
await RequestExecutor.ExecuteRequest(Scope.EquipmentMksUrl,
new RestRequest("/RemoveEquipment", Method.POST)
.AddHeader("Content-type", "application/json")
.AddJsonBody(JsonConvert.SerializeObject(new RemovingEquipmentModel
{
EquipmentId = equip.EquipmentId
}))));
if (!equipmentMksResult2.Success)
{
throw new Exception(equipmentMksResult2.Data);
}
}
_context.Repairs.Remove(repair);
await _context.SaveChangesAsync();
}
public async Task <IActionResult> Register(RegisterModel model)
{
if (ModelState.IsValid)
{
var user = await db.User.FirstOrDefaultAsync(u => u.UserName == model.UserName);
if (user == null)
{
// добавляем пользователя в бд
var newEmployeeId = await RequestExecutor.ExecuteRequest(Scope.EmployeeServiceUrl,
new RestRequest("/Employee", Method.POST)
.AddHeader("Content-type", "application/json")
.AddJsonBody(new
{
employeeName = "unknown",
dateBirth = DateTime.MinValue,
post = "employee",
cash = 0,
salary = 0,
}));
db.User.Add(new User {
UserName = model.UserName, Password = model.Password, Role = 1, IsBlocked = false, EmployeeId = int.Parse(newEmployeeId)
});
await db.SaveChangesAsync();
await Authenticate(model.UserName); // аутентификация
return(RedirectToAction("Index", "Home"));
}
else
{
ModelState.AddModelError("", "Некорректные логин и(или) пароль");
}
}
return(View(model));
}
public async Task UpdateRepairMaster(RepairWithMasterModel model)
{
var repair = await _context.Repairs.FirstOrDefaultAsync(x => x.RepairId == long.Parse(model.RepairId));
if (repair == null)
{
throw new Exception("Repair not found");
}
var personMksResultWithClient = JsonConvert.DeserializeObject <MksResponseResult>(
await RequestExecutor.ExecuteRequest(Scope.PersonMksUrl,
new RestRequest("/GetPersonIdByFIO", Method.POST)
.AddHeader("Content-type", "application/json")
.AddJsonBody(new
{
fio = model.Master
})));
if (!personMksResultWithClient.Success)
{
throw new Exception(personMksResultWithClient.Data);
}
repair.Master = long.Parse(personMksResultWithClient.Data);
await _context.SaveChangesAsync();
}
public async Task AddDefects(long equipmentId, long repairId, IEnumerable <EquipmentDefectsParam> defects)
{
var equipment = await _context.Equipments.FirstOrDefaultAsync(x => x.EquipmentId == equipmentId);
if (equipment == null)
{
throw new Exception("Equipment not found");
}
var repairDaysSum = default(int);
foreach (var defect in defects)
{
_context.EquipmentDefects.Add(new EquipmentDefects
{
DefectName = defect.DefectName,
EquipmentId = equipment.EquipmentId,
Price = decimal.Parse(defect.Price)
});
repairDaysSum += int.Parse(defect.RepairDays);
}
var repairMksResult = JsonConvert.DeserializeObject <MksResponseResult>(
await RequestExecutor.ExecuteRequest(Scope.RepairsMksUrl,
new RestRequest("/UpdateRepairDays", Method.POST)
.AddHeader("Content-type", "application/json")
.AddJsonBody(JsonConvert.SerializeObject(new RepairWithDaysModel
{
RepairId = repairId,
RepairDays = repairDaysSum
}))));
if (!repairMksResult.Success)
{
throw new Exception(repairMksResult.Data);
}
await _context.SaveChangesAsync();
}
async Task <T> Send <T>(T body, HttpMethod method, string overrideUrl = null, string token = null, Dictionary <string, object> requestParameters = null) where T : new()
{
var relativeUrl = overrideUrl;
T response;
try
{
var httpClient = new HttpClient()
{
BaseAddress = new Uri(_BaseUrl)
};
response = await RequestExecutor.ExecuteRequest(overrideUrl, method, body, httpClient, token, requestParameters);
}
catch (WebException ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
response = default(T);
}
return(response);
}
internal RequestHandlerFake(Method method, string path, List <IParameterResolver> parameterResolvers) : base(method, path, parameterResolvers)
{
_executor = (request, mediaTypeMapper1, errorHandler1, logger1) =>
RequestExecutor.ExecuteRequest(() => Completes.WithSuccess(Response.Of(ResponseStatus.Ok)), errorHandler1, logger1);
}
public async Task <RepairInfo> GetRepairReport(long repairId)
{
var repair = await _context.Repairs.FirstOrDefaultAsync(x => x.RepairId == repairId);
var repairInfo = new RepairInfo();
if (repair == null)
{
throw new Exception("Repair not found");
}
var personMksResultWithClient = JsonConvert.DeserializeObject <MksResponseResult>(
await RequestExecutor.ExecuteRequest(Scope.PersonMksUrl,
new RestRequest("/GetPersonById", Method.POST)
.AddHeader("Content-type", "application/json")
.AddJsonBody(new
{
id = repair.Client
})));
if (!personMksResultWithClient.Success)
{
throw new Exception(personMksResultWithClient.Data);
}
PersonModel master = null;
if (repair.Master != null)
{
var personMksResultWithMaster = JsonConvert.DeserializeObject <MksResponseResult>(
await RequestExecutor.ExecuteRequest(Scope.PersonMksUrl,
new RestRequest("/GetPersonById", Method.POST)
.AddHeader("Content-type", "application/json")
.AddJsonBody(new
{
id = repair.Master
})));
if (!personMksResultWithMaster.Success)
{
throw new Exception(personMksResultWithMaster.Data);
}
master = JsonConvert.DeserializeObject <PersonModel>(personMksResultWithMaster.Data);
}
var client = JsonConvert.DeserializeObject <PersonModel>(personMksResultWithClient.Data);
var equipmentMksResult = JsonConvert.DeserializeObject <MksResponseResult>(
await RequestExecutor.ExecuteRequest(Scope.EquipmentMksUrl,
new RestRequest("/SearchEquipmentsByRepair", Method.POST)
.AddHeader("Content-type", "application/json")
.AddParameter(new Parameter("repairId", repairId, ParameterType.RequestBody))));
if (!equipmentMksResult.Success)
{
throw new Exception(equipmentMksResult.Data);
}
var equipmentsInfo = JsonConvert.DeserializeObject <IEnumerable <EquipmentInfo> >(equipmentMksResult.Data);
var cost = default(decimal);
foreach (var equip in equipmentsInfo)
{
cost += equip.Defects.Sum(x => x.Price.Value);
}
repairInfo.Status = (RepairStatuses)repair.Status.Value;
repairInfo.StartDate = repair.StartDate.Value;
repairInfo.EndDate = repair.EndDate.Value;
repairInfo.RepairId = repair.RepairId;
repairInfo.RepairType = (RepairTypes)repair.RepairType.Value;
repairInfo.Master = master;
repairInfo.Client = client;
repairInfo.Equipments = equipmentsInfo;
repairInfo.Cost = cost;
return(repairInfo);
}
internal RequestHandlerFake(Method method, string path, List <IParameterResolver> parameterResolvers, RequestHandler0.Handler0 handler) : base(method, path, parameterResolvers)
{
_executor = (request, mediaTypeMapper1, errorHandler1, logger1) =>
RequestExecutor.ExecuteRequest(handler.Invoke, errorHandler1, logger1);
}
public RequestHandler6 <T, TR, TU, TI, TJ, TK> Handle(Handler6 handler)
{
_executor = (request, param1, param2, param3, param4, param5, param6, mediaTypeMapper1, errorHandler1, logger1)
=> RequestExecutor.ExecuteRequest(() => handler.Invoke(param1, param2, param3, param4, param5, param6), errorHandler1, logger1);
return(this);
}
public RequestHandler0 Handle(Handler0 handler)
{
_executor = (request, mediaTypeMapper1, errorHandler1, logger)
=> RequestExecutor.ExecuteRequest(() => handler.Invoke(), errorHandler1, logger);
return(this);
}
public RequestHandler2 <T, TR> Handle(Handler2 handler)
{
_executor = (request, param1, param2, mediaTypeMapper1, errorHandler1, logger1)
=> RequestExecutor.ExecuteRequest(() => handler.Invoke(param1, param2), errorHandler1, logger1);
return(this);
}
public async Task <bool> TryToPayOrder(long repairId)
{
var repair = await _context.Repairs.FirstOrDefaultAsync(x => x.RepairId == repairId);
if (repair == null)
{
throw new Exception("Repair not found");
}
var personMksResult1 = JsonConvert.DeserializeObject <MksResponseResult>(
await RequestExecutor.ExecuteRequest(Scope.PersonMksUrl,
new RestRequest("/GetPersonById", Method.POST)
.AddHeader("Content-type", "application/json")
.AddJsonBody(new
{
id = repair.Client.Value
})));
if (!personMksResult1.Success)
{
throw new Exception(personMksResult1.Data);
}
var person = JsonConvert.DeserializeObject <PersonModel>(personMksResult1.Data);
var equipmentMksResult = JsonConvert.DeserializeObject <MksResponseResult>(
await RequestExecutor.ExecuteRequest(Scope.EquipmentMksUrl,
new RestRequest("/SearchEquipmentsByRepair", Method.POST)
.AddHeader("Content-type", "application/json")
.AddParameter(new Parameter("repairId", repairId, ParameterType.RequestBody))));
if (!equipmentMksResult.Success)
{
throw new Exception(equipmentMksResult.Data);
}
var equipmentsInfo = JsonConvert.DeserializeObject <IEnumerable <EquipmentInfo> >(equipmentMksResult.Data);
var cost = default(decimal);
foreach (var equip in equipmentsInfo)
{
cost += equip.Defects.Sum(x => x.Price.Value);
}
if (person.Balance < cost)
{
return(false);
}
var personMksResult2 = JsonConvert.DeserializeObject <MksResponseResult>(
await RequestExecutor.ExecuteRequest(Scope.PersonMksUrl,
new RestRequest("/UpdateBalance", Method.POST)
.AddHeader("Content-type", "application/json")
.AddJsonBody(JsonConvert.SerializeObject(new BalanceModel
{
ClientId = person.PersonId,
RepairCost = cost
}))));
if (!personMksResult1.Success)
{
throw new Exception(personMksResult1.Data);
}
repair.Status = (byte)RepairStatuses.Paid;
await _context.SaveChangesAsync();
return(true);
}
