public ReportData GetData(int memberId)
{
ReportData reportData = new ReportData();
var memberRecord = _database.FetchMember(memberId);
reportData.MemberRecord = memberRecord;
// Get consultation records
var consultationRecords = _database.FetchConsultationRecordsForMember(memberId);
if (consultationRecords != null)
{
foreach (var consultationRecord in consultationRecords)
{
var providedService = new ProvidedService();
var providerRecord = _database.FetchProvider(consultationRecord.ProviderNumber);
var serviceRecord = _database.FetchServiceRecord(consultationRecord.ServiceNumber);
providedService.ServiceDate = consultationRecord.ServiceDate;
providedService.ProviderName = providerRecord.Name;
providedService.ServiceName = serviceRecord.Name;
reportData.ProvidedServices.Add(providedService);
}
}
return(reportData);
}
private static IProvidedService Convert(
IApplication application,
IService service,
ProvidedServiceDto dto)
{
var ps = new ProvidedService
{
Alias = ConvertMaybe(dto.Alias),
Service = service,
Title = dto.Options.GetValue("interop.ProvidedServiceOptions.title"),
Application = application,
To = ConvertMatchPatterns(dto.To),
LaunchMode = ConvertLaunchMode(
dto.Options.GetValue("interop.ProvidedServiceOptions.launch_on_call").GetValueOrDefault())
};
ps.Methods = dto.Methods
.Select(x => (IProvidedMethod) new ProvidedMethod
{
Method = service.Methods[x.Name],
ProvidedService = ps,
Title = x.Options.GetValue("interop.ProvidedMethodOptions.title"),
LaunchMode = ConvertLaunchMode(
x.Options.GetValue("interop.ProvidedMethodOptions.launch_on_call").GetValueOrDefault()),
TimeoutMs = int.TryParse(
x.Options.GetValue("interop.ProvidedMethodOptions.timeout_ms").GetValueOrDefault(),
out var result) ? result : 0,
Options = x.Options.Select(o => new Option {
Id = o.Id, Value = o.Value
}).ToList()
})
public override int GetHashCode()
{
unchecked
{
return(((ProvidedService != null ? ProvidedService.GetHashCode() : 0) * 397) ^ (MethodId != null ? MethodId.GetHashCode() : 0));
}
}
public async Task <Result <Exception, Guid> > Handle(CreateCommand request, CancellationToken cancellationToken)
{
ProvidedService providedService = _mapper.Map <ProvidedService>(request);
foreach (var employeesID in request.EmployeesID)
{
var employee = await _employeeRepository.GetByIdAsync(employeesID);
if (employee.IsSuccess)
{
providedService.Employees.Add(employee.Success);
}
}
var entity = await _repository.CreateAsync(providedService);
if (entity.IsFailure)
{
return(new Exception());
}
return(entity.Success.Id);
}
public async Task <CreateProvidedServiceViewModel> Handle(CreateProvidedServiceCommand request, CancellationToken cancellationToken)
{
var providedService = new ProvidedService(request.Title, request.Description, request.IdClient, request.IdFreelancer, request.TotalCost);
await _providedServiceRepository.Add(providedService);
return(new CreateProvidedServiceViewModel(providedService.Id, providedService.Title, providedService.Description, providedService.IdClient, providedService.IdFreelancer, providedService.TotalCost));
}
public override int GetHashCode()
{
unchecked
{
var hashCode = (ConsumedService != null ? ConsumedService.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (ProvidedService != null ? ProvidedService.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ ServiceTitle.GetHashCode();
hashCode = (hashCode * 397) ^ (Methods != null ? Methods.GetHashCode() : 0);
return(hashCode);
}
}
protected override void Cleanup()
{
ConsumedService?.Dispose();
ConsumedService = default;
ProvidedService?.Dispose();
ProvidedService = default;
foreach (var method in Methods)
{
method.Dispose();
}
Methods.Clear();
ServiceTitle = string.Empty;
}
protected override void Cleanup()
{
ConsumedService?.Dispose();
ConsumedService = default;
ProvidedService?.Dispose();
ProvidedService = default;
ServiceTitle = default;
if (Methods != null)
{
foreach (var method in Methods)
{
method?.Dispose();
}
}
Methods = default;
}
public ActionResult Edit([Bind(Include = "Id,ServiceDate,NumberOfMinutes,ClientId,ServiceId")] ProvidedService providedService)
{
try
{
if (ModelState.IsValid)
{
db.Entry(providedService).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index", new { clientId = providedService.ClientId }));
}
}
catch (DataException)
{
//Log the error
ModelState.AddModelError("", PageStrings.EditErrorMessageText);
}
PopulateClientsDropDownList(providedService.ClientId);
PopulateServicesDropDownList(providedService.ServiceId);
return(View(providedService));
}
public ActionResult Create([Bind(Include = "ServiceDate,NumberOfMinutes,ClientId,ServiceId")] ProvidedService providedService)
{
try
{
if (ModelState.IsValid)
{
db.ProvidedServices.Add(providedService);
db.SaveChanges();
return(RedirectToAction("Index", new { clientId = providedService.ClientId }));
}
}
catch (RetryLimitExceededException)
{
//Log the error
ModelState.AddModelError("", PageStrings.CreateErrorMessageText);
}
PopulateClientsDropDownList(providedService.ClientId);
PopulateServicesDropDownList(providedService.ServiceId);
return(View(providedService));
}
private static IProvidedService Convert(
IApplication application,
IService service,
ProvidedServiceDto dto)
{
var ps = new ProvidedService
{
Alias = ConvertMaybe(dto.Alias),
Service = service,
Title = ConvertMaybe(dto.Title),
Application = application,
To = ConvertMatchPatterns(dto.To)
};
ps.Methods = dto.Methods
.Select(x => (IProvidedMethod) new ProvidedMethod {
Method = service.Methods[x.Name], ProvidedService = ps, Title = ConvertMaybe(x.Title)
})
.ToDictionary(x => x.Method.Name, x => x);
return(ps);
}
public async Task Add(ProvidedService providedService)
{
//Entity Framework
//await _dbContext.ProvidedServices.AddAsync(providedService);
//await _dbContext.SaveChangesAsync();
//Dapper
using (var sqlConnection = new MySqlConnection(_connectionString))
{
var parameters = new
{
title = providedService.Title,
description = providedService.Description,
idclient = providedService.IdClient,
idfreelancer = providedService.IdFreelancer,
totalcost = providedService.TotalCost
};
var sql = @"INSERT INTO ProvidedServices (Title, Description, IdClient, IdFreelancer, CreatedAt, TotalCost, Status)
VALUES(@title, @description, @idclient, @idfreelancer, NOW(), @totalcost, 0)";
await sqlConnection.ExecuteAsync(sql, parameters);
}
}
protected override void Cleanup()
{
ProvidedService?.Dispose();
ProvidedService = default;
MethodId = string.Empty;
}
public async Task Add(ProvidedService providedService)
{
await _dbContext.ProvidedServices.AddAsync(providedService);
await _dbContext.SaveChangesAsync();
}
