public async Task <ActionResult <IEnumerable <PlaceProductWithPlace> > > ListPlaceProductByPlace(
[FromQuery] string placeId
)
{
try
{
var place = await placeRepository.GetPlace(placeId);
if (place == null)
{
throw new Exception("Place not found");
}
var pp = await placeProviderRepository.GetPlaceProvider(place.PlaceProviderId);
if (pp == null)
{
throw new Exception("Place provider not found");
}
var ret = await placeRepository.ListPlaceProductByPlace(placeId);
var places2 = IPlaceProviderRepository.ExtendByAllProducts(ret, pp, new string[] { placeId });
return(Ok(places2.Select(ppr => ppr.ToExtendedModel(placeProviderRepository).Result)));
}
catch (Exception exc)
{
logger.LogError(exc, exc.Message);
return(BadRequest(new ProblemDetails()
{
Detail = exc.Message
}));
}
}
public async Task <ActionResult <IEnumerable <PlaceProduct> > > ListPlaceProductByPlaceProvider(
[FromQuery] string placeProviderId
)
{
try
{
var pp = await placeProviderRepository.GetPlaceProvider(placeProviderId);
if (pp == null)
{
throw new Exception("Place provider not found");
}
var ret = await placeRepository.ListPlaceProductByPlaceProvider(pp);
var places = await placeRepository.ListAll();
return(Ok(IPlaceProviderRepository.ExtendByAllProducts(ret, pp, places.Where(pp => pp.PlaceProviderId == placeProviderId).Select(p => p.Id).ToArray())));
}
catch (Exception exc)
{
logger.LogError(exc, exc.Message);
return(BadRequest(new ProblemDetails()
{
Detail = exc.Message
}));
}
}
public async Task <ActionResult <IEnumerable <PlaceProductWithPlace> > > ListPlaceProduct()
{
try
{
var pp = await placeProviderRepository.GetPlaceProvider(User.GetPlaceProvider());
if (pp == null)
{
throw new Exception("Place provider not found");
}
var ret = await placeRepository.ListPlaceProductByPlaceProvider(pp);
var places = await placeRepository.ListAll();
var places2 = IPlaceProviderRepository.ExtendByAllProducts(ret, pp, places.Where(pp => pp.PlaceProviderId == User.GetPlaceProvider()).Select(p => p.Id).ToArray());
return(Ok(places2.Select(ppr => ppr.ToExtendedModel(placeProviderRepository).Result)));
}
catch (ArgumentException exc)
{
logger.LogError(exc.Message);
return(BadRequest(new ProblemDetails()
{
Detail = exc.Message
}));
}
catch (Exception exc)
{
logger.LogError(exc, exc.Message);
return(BadRequest(new ProblemDetails()
{
Detail = exc.Message
}));
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="localizer"></param>
/// <param name="configuration"></param>
/// <param name="loggerFactory"></param>
/// <param name="logger"></param>
/// <param name="slotRepository"></param>
/// <param name="placeRepository"></param>
/// <param name="userRepository"></param>
/// <param name="visitorRepository"></param>
/// <param name="placeProviderRepository"></param>
/// <param name="mojeEZdravie"></param>
/// <param name="emailSender"></param>
/// <param name="smsSender"></param>
public AdminController(
IStringLocalizer <AdminController> localizer,
IConfiguration configuration,
ILoggerFactory loggerFactory,
ILogger <AdminController> logger,
ISlotRepository slotRepository,
IPlaceRepository placeRepository,
IUserRepository userRepository,
IVisitorRepository visitorRepository,
IPlaceProviderRepository placeProviderRepository,
IMojeEZdravie mojeEZdravie,
IEmailSender emailSender,
ISMSSender smsSender
)
{
this.localizer = localizer;
this.loggerFactory = loggerFactory;
this.logger = logger;
this.slotRepository = slotRepository;
this.placeRepository = placeRepository;
this.userRepository = userRepository;
this.configuration = configuration;
this.visitorRepository = visitorRepository;
this.placeProviderRepository = placeProviderRepository;
this.mojeEZdravie = mojeEZdravie;
this.emailSender = emailSender;
this.smsSender = smsSender;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="localizer"></param>
/// <param name="configuration"></param>
/// <param name="loggerFactory"></param>
/// <param name="redisCacheClient"></param>
/// <param name="emailSender"></param>
/// <param name="smsSender"></param>
/// <param name="placeRepository"></param>
/// <param name="slotRepository"></param>
/// <param name="placeProviderRepository"></param>
/// <param name="userRepository"></param>
public VisitorRepository(
IStringLocalizer <Repository.RedisRepository.VisitorRepository> localizer,
IConfiguration configuration,
ILoggerFactory loggerFactory,
IRedisCacheClient redisCacheClient,
IEmailSender emailSender,
ISMSSender smsSender,
IPlaceRepository placeRepository,
ISlotRepository slotRepository,
IPlaceProviderRepository placeProviderRepository,
IUserRepository userRepository
) : base(
localizer,
configuration,
loggerFactory.CreateLogger <Repository.RedisRepository.VisitorRepository>(),
redisCacheClient,
emailSender,
smsSender,
placeRepository,
slotRepository,
placeProviderRepository,
userRepository
)
{
logger = loggerFactory.CreateLogger <VisitorRepository>();
this.configuration = configuration;
}
/// <summary>
/// Returns true if the user is currently in the role of PP Admin and acts on behalf of specific place.
/// </summary>
/// <param name="user"></param>
/// <param name="userRepository"></param>
/// <param name="placeProviderRepository"></param>
/// <param name="placeRepository"></param>
/// <param name="placeId"></param>
/// <returns></returns>
public static async Task <bool> IsPlaceAdmin(
this ClaimsPrincipal user,
IUserRepository userRepository,
IPlaceProviderRepository placeProviderRepository,
IPlaceRepository placeRepository,
string placeId
)
{
var place = await placeRepository.GetPlace(placeId);
if (place == null)
{
return(false);
}
if (user.IsAdmin(userRepository))
{
return(true);
}
var pp = GetPlaceProvider(user);
if (pp != place.PlaceProviderId)
{
return(false);
}
return(await placeProviderRepository.InAnyGroup(user.GetEmail(), pp, new string[] { Groups.PPAdmin }));
}
/// <summary>
/// Extend
/// </summary>
/// <param name="placeProviderRepository"></param>
/// <returns></returns>
internal async Task <PlaceProductWithPlace> ToExtendedModel(IPlaceProviderRepository placeProviderRepository)
{
var pp = await placeProviderRepository.GetPlaceProvider(PlaceProviderId);
return(new PlaceProductWithPlace()
{
Id = this.Id,
CustomPrice = this.CustomPrice,
From = From,
InsuranceOnly = InsuranceOnly,
CollectInsurance = CollectInsurance,
CollectEmployeeNo = CollectEmployeeNo,
CollectNationality = CollectNationality,
EmployeesOnly = EmployeesOnly,
EmployeesRegistration = EmployeesRegistration,
SchoolOnly = SchoolOnly,
EHealthDefault = EHealthDefault,
PlaceId = PlaceId,
PlaceProviderId = PlaceProviderId,
Price = Price,
PriceCurrency = PriceCurrency,
Product = pp?.Products?.FirstOrDefault(pr => pr.Id == ProductId),
ProductId = ProductId,
Until = Until,
});
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="localizer"></param>
/// <param name="logger"></param>
/// <param name="userRepository"></param>
/// <param name="placeProviderRepository"></param>
public UserController(
IStringLocalizer <UserController> localizer,
ILogger <PlaceController> logger,
IUserRepository userRepository,
IPlaceProviderRepository placeProviderRepository
)
{
this.localizer = localizer;
this.logger = logger;
this.userRepository = userRepository;
this.placeProviderRepository = placeProviderRepository;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="configuration"></param>
/// <param name="localizer"></param>
/// <param name="logger"></param>
/// <param name="placeProviderRepository"></param>
/// <param name="placeRepository"></param>
/// <param name="userRepository"></param>
public PlaceProviderController(
IConfiguration configuration,
IStringLocalizer <PlaceProviderController> localizer,
ILogger <PlaceProviderController> logger,
IPlaceProviderRepository placeProviderRepository,
IPlaceRepository placeRepository,
IUserRepository userRepository
)
{
this.configuration = configuration;
this.localizer = localizer;
this.logger = logger;
this.placeRepository = placeRepository;
this.userRepository = userRepository;
this.placeProviderRepository = placeProviderRepository;
}
/// <summary>
/// constructor
/// </summary>
/// <param name="logger"></param>
/// <param name="visitorRepository"></param>
/// <param name="userRepository"></param>
/// <param name="placeProviderRepository"></param>
/// <param name="configuration"></param>
/// <param name="captchaValidator"></param>
public VisitorController(
ILogger <VisitorController> logger,
IVisitorRepository visitorRepository,
IUserRepository userRepository,
IPlaceProviderRepository placeProviderRepository,
IConfiguration configuration,
GoogleReCaptcha.V3.Interface.ICaptchaValidator captchaValidator
)
{
this.logger = logger;
this.visitorRepository = visitorRepository;
this.configuration = configuration;
this.captchaValidator = captchaValidator;
this.userRepository = userRepository;
this.placeProviderRepository = placeProviderRepository;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="configuration"></param>
/// <param name="localizer"></param>
/// <param name="logger"></param>
/// <param name="visitorRepository"></param>
/// <param name="userRepository"></param>
/// <param name="placeProviderRepository"></param>
/// <param name="captchaValidator"></param>
public ResultController(
IConfiguration configuration,
IStringLocalizer <ResultController> localizer,
ILogger <ResultController> logger,
IVisitorRepository visitorRepository,
IUserRepository userRepository,
IPlaceProviderRepository placeProviderRepository,
ICaptchaValidator captchaValidator
)
{
this.configuration = configuration;
this.localizer = localizer;
this.logger = logger;
this.visitorRepository = visitorRepository;
this.userRepository = userRepository;
this.placeProviderRepository = placeProviderRepository;
this.captchaValidator = captchaValidator;
}
/// <summary>
/// Extend
/// </summary>
/// <param name="placeProviderRepository"></param>
/// <returns></returns>
internal async Task <PlaceProductWithPlace> ToExtendedModel(IPlaceProviderRepository placeProviderRepository)
{
var pp = await placeProviderRepository.GetPlaceProvider(PlaceProviderId);
return(new PlaceProductWithPlace()
{
Id = this.Id,
CustomPrice = this.CustomPrice,
From = From,
InsuranceOnly = InsuranceOnly,
PlaceId = PlaceId,
PlaceProviderId = PlaceProviderId,
Price = Price,
PriceCurrency = PriceCurrency,
Product = pp?.Products?.FirstOrDefault(pr => pr.Id == ProductId),
ProductId = ProductId,
Until = Until,
});
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="localizer"></param>
/// <param name="configuration"></param>
/// <param name="logger"></param>
/// <param name="redisCacheClient"></param>
/// <param name="emailSender"></param>
/// <param name="smsSender"></param>
/// <param name="placeRepository"></param>
/// <param name="placeProviderRepository"></param>
public UserRepository(
IStringLocalizer <UserRepository> localizer,
IConfiguration configuration,
ILogger <UserRepository> logger,
IRedisCacheClient redisCacheClient,
IEmailSender emailSender,
ISMSSender smsSender,
IPlaceRepository placeRepository,
IPlaceProviderRepository placeProviderRepository
)
{
this.localizer = localizer;
this.logger = logger;
this.redisCacheClient = redisCacheClient;
this.emailSender = emailSender;
this.smsSender = smsSender;
this.configuration = configuration;
this.placeRepository = placeRepository;
this.placeProviderRepository = placeProviderRepository;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="localizer"></param>
/// <param name="configuration"></param>
/// <param name="logger"></param>
/// <param name="slotRepository"></param>
/// <param name="placeRepository"></param>
/// <param name="userRepository"></param>
/// <param name="visitorRepository"></param>
/// <param name="placeProviderRepository"></param>
public AdminController(
IStringLocalizer <AdminController> localizer,
IConfiguration configuration,
ILogger <AdminController> logger,
ISlotRepository slotRepository,
IPlaceRepository placeRepository,
IUserRepository userRepository,
IVisitorRepository visitorRepository,
IPlaceProviderRepository placeProviderRepository
)
{
this.localizer = localizer;
this.logger = logger;
this.slotRepository = slotRepository;
this.placeRepository = placeRepository;
this.userRepository = userRepository;
this.configuration = configuration;
this.visitorRepository = visitorRepository;
this.placeProviderRepository = placeProviderRepository;
}
/// <summary>
/// ListPlaceProductByCategory
/// </summary>
/// <param name="category"></param>
/// <returns></returns>
public async Task <IEnumerable <PlaceProduct> > ListPlaceProductByCategory(string category)
{
var ret = new List <PlaceProduct>();
foreach (var ppId in await ListPPIdsByCategory(category))
{
var pp = await GetPlaceProvider(ppId);
if (pp.Products.Any(p => p.Category == category))
{
ret.AddRange(await placeRepository.ListPlaceProductByPlaceProvider(pp));
}
var places = await placeRepository.ListAll();
var placesIds = places.Where(ppobj => ppobj.PlaceProviderId == pp.PlaceProviderId).Select(p => p.Id).ToArray();
ret = IPlaceProviderRepository.ExtendByAllProducts(ret, pp, placesIds);
}
return(ret);
}
/// <summary>
/// constructor
/// </summary>
/// <param name="localizer"></param>
/// <param name="localizer2"></param>
/// <param name="configuration"></param>
/// <param name="loggerFactory"></param>
/// <param name="redisCacheClient"></param>
/// <param name="emailSender"></param>
/// <param name="smsSender"></param>
/// <param name="placeRepository"></param>
/// <param name="placeProviderRepository"></param>
public UserRepository(
IStringLocalizer <UserRepository> localizer,
IStringLocalizer <Repository.RedisRepository.UserRepository> localizer2,
IConfiguration configuration,
ILoggerFactory loggerFactory,
IRedisCacheClient redisCacheClient,
IEmailSender emailSender,
ISMSSender smsSender,
IPlaceRepository placeRepository,
IPlaceProviderRepository placeProviderRepository
) : base(
localizer2,
configuration,
loggerFactory.CreateLogger <Repository.RedisRepository.UserRepository>(),
redisCacheClient,
emailSender,
smsSender,
placeRepository,
placeProviderRepository
)
{
this.localizer = localizer;
this.placeProviderRepository = placeProviderRepository;
}
/// <summary>
/// Returns true if the user is currently in the role of PP Admin.
/// </summary>
/// <param name="user"></param>
/// <param name="userRepository"></param>
/// <param name="placeProviderRepository"></param>
/// <returns></returns>
public static async Task <bool> IsPlaceProviderAdmin(this ClaimsPrincipal user, IUserRepository userRepository, IPlaceProviderRepository placeProviderRepository)
{
if (user.IsAdmin(userRepository))
{
return(true);
}
var pp = GetPlaceProvider(user);
return(await placeProviderRepository.InAnyGroup(user.GetEmail(), pp, new string[] { Groups.PPAdmin }));
}
/// <summary>
/// Check if user has role Data exporter
/// </summary>
/// <param name="user"></param>
/// <param name="userRepository"></param>
/// <param name="placeProviderRepository"></param>
/// <returns></returns>
public static bool IsDataExporter(this ClaimsPrincipal user, IUserRepository userRepository, IPlaceProviderRepository placeProviderRepository)
{
if (user is null)
{
throw new ArgumentNullException(nameof(user));
}
if (userRepository is null)
{
throw new ArgumentNullException(nameof(userRepository));
}
var email = user.GetEmail();
var pp = user.GetPlaceProvider();
if (!string.IsNullOrEmpty(pp))
{
if (placeProviderRepository.InAnyGroup(email, pp, new string[] { Groups.DataExporter }).Result)
{
return(true);
}
}
return(userRepository.InAnyGroup(email, new string[] { Groups.DataExporter }, user.GetPlaceProvider()).Result);
}
/// <summary>
/// Accountant or admin is authorized to issue invoice
/// </summary>
/// <param name="user"></param>
/// <param name="userRepository"></param>
/// <param name="placeProviderRepository"></param>
/// <param name="placeProviderId"></param>
/// <returns></returns>
public static bool IsAuthorizedToIssueInvoice(this ClaimsPrincipal user, IUserRepository userRepository, IPlaceProviderRepository placeProviderRepository, string placeProviderId)
{
if (user is null)
{
throw new ArgumentNullException(nameof(user));
}
if (userRepository is null)
{
throw new ArgumentNullException(nameof(userRepository));
}
if (placeProviderRepository is null)
{
throw new ArgumentNullException(nameof(placeProviderRepository));
}
if (string.IsNullOrEmpty(placeProviderId))
{
throw new ArgumentNullException(nameof(placeProviderId));
}
var email = user.GetEmail();
return(placeProviderRepository.InAnyGroup(email, placeProviderId, new string[] { Groups.Admin, Groups.Accountant }).Result);
}
/// <summary>
/// Log in as company
/// </summary>
/// <param name="user"></param>
/// <param name="userRepository"></param>
/// <param name="placeProviderRepository"></param>
/// <param name="placeProviderId"></param>
/// <returns></returns>
public static async Task <bool> IsAuthorizedToLogAsCompany(this ClaimsPrincipal user, IUserRepository userRepository, IPlaceProviderRepository placeProviderRepository, string placeProviderId)
{
if (user is null)
{
throw new ArgumentNullException(nameof(user));
}
if (userRepository is null)
{
throw new ArgumentNullException(nameof(userRepository));
}
if (user.IsAdmin(userRepository))
{
return(true);
}
if (placeProviderRepository is null)
{
throw new ArgumentNullException(nameof(placeProviderRepository));
}
if (string.IsNullOrEmpty(placeProviderId))
{
throw new ArgumentNullException(nameof(placeProviderId));
}
var email = user.GetEmail();
var pp = await placeProviderRepository.GetPlaceProvider(placeProviderId);
if (pp == null)
{
return(false);
}
if (pp.Users?.Any(u => u.Email == email) == true)
{
return(true);
}
return(await placeProviderRepository.InAnyGroup(email, placeProviderId, new string[] { Groups.Admin, Groups.PPAdmin, Groups.Accountant, Groups.DataExporter, Groups.DocumentManager, Groups.MedicLab, Groups.MedicTester, Groups.RegistrationManager }));
}
/// <summary>
/// Downloads the visitors from eHealth
/// </summary>
/// <param name="placeProviderId"></param>
/// <param name="managerEmail"></param>
/// <param name="day"></param>
/// <param name="visitorRepository"></param>
/// <param name="placeRepository"></param>
/// <param name="placeProviderRepository"></param>
/// <param name="slotRepository"></param>
/// <param name="loggerFactory"></param>
/// <returns></returns>
public async Task <int> DownloadEHealthVisitors(
string placeProviderId,
string managerEmail,
DateTimeOffset day,
IVisitorRepository visitorRepository,
IPlaceRepository placeRepository,
IPlaceProviderRepository placeProviderRepository,
ISlotRepository slotRepository,
ILoggerFactory loggerFactory
)
{
var logger = loggerFactory.CreateLogger <MojeEZdravieAbstract>();
logger.LogInformation($"eHealth: Downloading {placeProviderId} {managerEmail} {day}");
var rPlaces = (await placeRepository.ListAll())?.Where(p => p.PlaceProviderId == placeProviderId);
if (rPlaces == null || !rPlaces.Any())
{
throw new Exception("This place provider does not have any place defined");
}
var pp = await placeProviderRepository.GetPlaceProvider(placeProviderId);
var product = pp.Products.FirstOrDefault(pr => pr.EHealthDefault == true);
if (product == null)
{
product = pp.Products.FirstOrDefault();
}
int ret = 0;
var data = await MakeSurePlaceProviderIsAuthenticated(placeProviderId, placeProviderRepository);
var token = data.LoginPayload.Session.Token;
var places = await DriveInQueue(token, day);
if (places.Payload == null)
{
throw new Exception("No places found");
}
foreach (var place in places.Payload)
{
var rPlace = rPlaces.FirstOrDefault(p => p.EHealthId == place.Id);
if (rPlace == null)
{
rPlace = rPlaces.FirstOrDefault();
}
var list = await PlaceDetail(token, day, place.Id);
foreach (var person in list.Payload)
{
if (!person.DesignatedDriveinScheduledAt.HasValue)
{
continue;
}
if (string.IsNullOrEmpty(person.BirthNumber?.FormatDocument()))
{
continue;
}
var slot = await slotRepository.GetCurrentSlot(rPlace.Id, person.DesignatedDriveinScheduledAt.Value);
var documentClear = person.BirthNumber.FormatDocument();
var existing = await visitorRepository.GetVisitorByPersonalNumber(documentClear, true);
if (existing != null && existing.ChosenPlaceId == rPlace.Id && existing.ChosenSlot == slot.SlotId)
{
continue; // already exists
}
var visitor = new Visitor()
{
ChosenSlot = slot.SlotId,
ChosenPlaceId = rPlace.Id,
Product = product.Id,
FirstName = person.FirstName,
LastName = person.LastName,
RC = person.BirthNumber,
Insurance = person.HealthInsuranceCompany,
PersonTrackingNumber = person.PersonTrackingNumber,
Gender = person.Gender,
Street = person.Street,
StreetNo = person.StreetNumber,
City = person.City,
ZIP = person.PostalCode,
Phone = person.PrimaryPhone,
Language = "sk",
Result = TestResult.NotTaken,
DownloadedAt = DateTimeOffset.UtcNow
};
var newRegistration = await visitorRepository.Register(visitor, managerEmail, false);
logger.LogInformation($"eHealth: Visitor downloaded {visitor.Id} {visitor.RC.GetSHA256Hash()}");
ret++;
}
}
return(ret);
}
private async Task <PlaceProviderSensitiveData> MakeSurePlaceProviderIsAuthenticated(string placeProviderId, IPlaceProviderRepository placeProviderRepository)
{
var data = await placeProviderRepository.GetPlaceProviderSensitiveData(placeProviderId);
if (data.SessionValidity == null || data.SessionValidity.ValidThru.AddMinutes(10) < DateTimeOffset.Now)
{
// session is going to expire
if (data.SessionValidity == null || data.SessionValidity.ValidThru.AddMinutes(10) < DateTimeOffset.Now)
{
if (data.SessionValidity == null || data.SessionValidity.ValidThru.AddMinutes(1) < DateTimeOffset.Now)
{
// expired .. login again
data.LoginPayload = (await Authenticate(data.EZdravieUser, data.EZdraviePass))?.Payload;
if (string.IsNullOrEmpty(data.LoginPayload.User.Login))
{
throw new Exception("Unable to authenticate to ehealth");
}
}
// extend session
var extendSessionRequest = new ExtendSessionRequest()
{
AccessId = data.LoginPayload.Session.SessionId,
UserId = data.LoginPayload.User.Id
};
data.SessionValidity = await Extendsession(data.LoginPayload.Session.Token, extendSessionRequest);
if (data.SessionValidity == null)
{
data.SessionValidity = new ExtendSessionResponse()
{
ValidThru = data.LoginPayload.Session.ValidThru
};
}
if (data.SessionValidity.ValidThru.AddMinutes(1) < DateTimeOffset.Now)
{
throw new Exception("Unable to prolong the session");
}
await placeProviderRepository.SetPlaceProviderSensitiveData(data, false);
}
}
return(data);
}
/// <summary>
/// Send visitor registered in rychlejsie or downloaded from eHealth to eHealth system
///
/// Returns true if successful, False or Exception if not successful
/// </summary>
/// <param name="visitor"></param>
/// <param name="placeProviderId"></param>
/// <param name="placeProviderRepository"></param>
/// <param name="configuration"></param>
/// <returns></returns>
public async Task <bool> SendResultToEHealth(
Visitor visitor,
string placeProviderId,
IPlaceProviderRepository placeProviderRepository,
IConfiguration configuration
)
{
await SendResultToEHealth(visitor);
var data = await MakeSurePlaceProviderIsAuthenticated(placeProviderId, placeProviderRepository);
if (visitor.PersonType == "foreign")
{
throw new Exception("Only residents supported right now");
}
// session is valid
if (string.IsNullOrEmpty(visitor.RC))
{
throw new Exception("Error - invalid personal number");
}
var check = await this.CheckPerson(data.LoginPayload.Session.Token, visitor.RC);
if (check?.CfdId > 0)
{
// ok
}
else
{
if (configuration["AllowEHealthRegistration"] != "1")
{
return(false);
}
var personData = await RegisterPerson(data.LoginPayload.Session.Token, RegisterPersonRequest.FromVisitor(visitor, data.LoginPayload));
check = await this.CheckPerson(data.LoginPayload.Session.Token, visitor.RC);
if (check?.CfdId > 0)
{
// ok
}
else
{
throw new Exception("Unable to process visitor in ehealth - not found in search");
}
}
var driveIn = await DriveInQueue(data.LoginPayload.Session.Token, DateTimeOffset.Now);
var place = driveIn.Payload.OrderByDescending(p => p.DailyCapacity).FirstOrDefault();
var t = DateTimeOffset.Now.ToString("yyyy-MM-dd HH:mm:ss");
var input = new DriveInRequest()
{
DesignatedDriveinCity = place.City,
DesignatedDriveinId = place.Id,
DesignatedDriveinLatitude = place.Latitude,
DesignatedDriveinLongitude = place.Longitude,
DesignatedDriveinScheduledAt = t,
DesignatedDriveinStreetName = place.StreetName,
DesignatedDriveinStreetNumber = place.StreetNumber,
DesignatedDriveinTitle = place.Title,
DesignatedDriveinZipCode = place.ZipCode,
MedicalAssessedAt = t,
State = "SD",
Triage = "2",
};
var addPersonToPlace = await AddPersonToTestingPlace(data.LoginPayload.Session.Token, check.CfdId, input);
if (addPersonToPlace != "1")
{
throw new Exception("Unexpected error returned while adding person to place");
}
string result;
switch (visitor.Result)
{
case TestResult.PositiveWaitingForCertificate:
case TestResult.PositiveCertificateTaken:
result = "POSITIVE";
break;
case TestResult.NegativeWaitingForCertificate:
case TestResult.NegativeCertificateTaken:
case TestResult.NegativeCertificateTakenTypo:
result = "NEGATIVE";
break;
default:
throw new Exception($"Unable to determine state: {visitor.Result}");
}
var setResultRequest = new CovidMassTesting.Model.EZdravie.Request.SetResultRequest()
{
Id = 0,
UserId = data.LoginPayload.User.Id,
CovidFormDataId = check.CfdId,
FinalResult = result,
ScreeningFinalResult = result,
SpecimenId = visitor.TestingSet,
SpecimenCollectedAt = visitor.TestingTime.Value.ToString("yyyy-MM-dd HH:mm:ss"),
ScreeningEndedAt = visitor.TestResultTime?.ToString("yyyy-MM-dd HH:mm:ss") ?? visitor.TestingTime.Value.ToString("yyyy-MM-dd HH:mm:ss"),
};
var setResult = await SetTestResultToPerson(data.LoginPayload.Session.Token, setResultRequest);
return(setResult[0][0].HttpStatusCode == 200);
}
