public FinderResults <PatientDto> FinderSearch(int page, int pageSize, string search = null)
{
var start = page * pageSize;
var end = start + pageSize;
var replaceString = string.IsNullOrWhiteSpace(search) ? "" : WhereConstraint;
var completeQuery = string.Format(Query, replaceString);
using (var connection = _connectionFactory.CreateConnection())
using (var multiQuery = connection.QueryMultiple(completeQuery, new { start, end, UserContext.Current.OrganizationKey, search }))
{
var totalCount = multiQuery.Read <int>().Single();
var patientDtos =
multiQuery.Read <PersonName, string, PatientDto, PatientDto>((personName, code, patientDto) =>
{
patientDto.Name = personName;
var lookupDto = new LookupDto
{
Code = code,
Name = _resourcesManager.GetResourceManagerByName("Gender").GetString(code)
};
patientDto.Gender = lookupDto;
return(patientDto);
}, "Code,Key").ToList();
var finderResults = new FinderResults <PatientDto>()
{
Data = patientDtos,
TotalCount = totalCount
};
return(finderResults);
}
}
public ContactSkillDto Convert(ContactSkill source, ContactSkillDto destination, ResolutionContext context)
{
if (destination == null)
{
destination = new ContactSkillDto();
}
if (source == null)
{
return(destination);
}
destination.Id = source.Id;
LookupDto skill = AsyncHelper.RunSync(() => this.lookupService.GetSkillAsync(source.SkillId, default));
destination.Skill = context.Mapper.Map <LookupDto>(skill);
LookupDto expertiseLevel = AsyncHelper.RunSync(() => this.lookupService.GetExpertiseLevelAsync(source.ExpertiseLevelId, default));
destination.ExpertiseLevel = context.Mapper.Map <LookupDto>(expertiseLevel);
destination.ContactId = source.ContactId;
return(destination);
}
private static void UpdateCustomProperty(PersonDto personDto, LookupDto lookups)
{
var gender = lookups.Genders.FirstOrDefault(x => x.Id == personDto.GenderId);
if (gender != null)
{
personDto.Gender = gender.Name;
}
var ethnicity = lookups.Ethnicities.FirstOrDefault(x => x.Id == personDto.EthnicityId);
if (ethnicity != null)
{
personDto.Ethnicity = ethnicity.Name;
}
var language = lookups.Languages.FirstOrDefault(x => x.Id == personDto.PreferredLanguageId);
if (language != null)
{
personDto.Language = language.Name;
}
var title = lookups.Titles.FirstOrDefault(x => x.Id == personDto.TitleId);
if (title != null)
{
personDto.Title = title.Name;
}
var nationality = lookups.Nationalities.FirstOrDefault(x => x.Id == personDto.NationalityTypeId);
if (nationality != null)
{
personDto.Nationality = nationality.Name;
}
}
public DataTableResponse <PatientDto> DataTableSearch(string sEcho, int iDisplayStart, int iDisplayLength, string sSearch = null)
{
var start = iDisplayStart;
var end = start + iDisplayLength;
var replaceString = string.IsNullOrWhiteSpace(sSearch) ? "" : WhereConstraint;
var completeQuery = string.Format(Query, replaceString);
using (var connection = _connectionFactory.CreateConnection())
using (var multiQuery = connection.QueryMultiple(completeQuery, new { start, end, UserContext.Current.OrganizationKey, search = sSearch }))
{
var totalCount = multiQuery.Read <int>().Single();
var patientDtos =
multiQuery.Read <PersonName, string, PatientDto, PatientDto>((personName, code, patientDto) =>
{
patientDto.Name = personName;
var lookupDto = new LookupDto
{
Code = code,
Name = _resourcesManager.GetResourceManagerByName("Gender").GetString(code)
};
patientDto.Gender = lookupDto;
return(patientDto);
}, "Code,Key");
var dataTableResponse = new DataTableResponse <PatientDto>
{
Data = patientDtos.ToList(),
Echo = sEcho,
TotalDisplayRecords = totalCount,
TotalRecords = totalCount,
};
return(dataTableResponse);
}
}
/// <summary>
/// to createlookup collection
/// </summary>
/// <param name="lookupObj">lookup object</param>
public void Post(LookupDto lookupObj)
{
try
{
ServiceFactory.GetLookupService("EmployerDepartment").Create(lookupObj);
}
catch (Exception ex) { }
}
private async Task UpdateAsync(LookupDto input)
{
if (input.Id != null)
{
var lookup = await _lookupRepository.FirstOrDefaultAsync((int)input.Id);
ObjectMapper.Map(input, lookup);
}
}
public async Task CreateOrUpdateLookup(LookupDto input)
{
if (input.Id == null)
{
await CreateAsync(input);
}
else
{
await UpdateAsync(input);
}
}
public async Task <IActionResult> AddUser(LookupDto user)
{
var result = await Mediator.Send(new AddUserCommand()
{
Id = user.Id,
Name = user.Name,
IsActive = user.IsActive,
});
return(Ok(result));
}
/// <summary>
/// Gets the resource.
/// </summary>
/// <param name="htmlHelper">The HTML helper.</param>
/// <param name="lookupDto">The lookup dto.</param>
/// <returns>The resource for the lookup.</returns>
public static string GetResource(this HtmlHelper htmlHelper, LookupDto lookupDto)
{
var resourceManager = htmlHelper.ViewData["ResourceManager"] as ResourceManager;
var resource = string.Empty;
if (resourceManager != null)
{
resource = resourceManager.GetString("_" + lookupDto.Code);
}
return(resource);
}
private async Task <LookupDto> GetLookupDtoAsync <TLookup>(int id, CancellationToken cancellationToken)
where TLookup : class, ILookup, new()
{
LookupDto lookupDto = (await this.GetLookupDtosAsync <TLookup>(cancellationToken)).FirstOrDefault(l => l.Id == id);
if (lookupDto == null)
{
throw new ArgumentException($"There is no {typeof(TLookup).Name} with Id {id}.");
}
return(lookupDto);
}
public async Task <IActionResult> EditUser(LookupDto user)
{
var result = await Mediator.Send(new EditUserCommand()
{
Id = user.Id,
Name = user.Name,
IsActive = user.IsActive
});
if (result == Guid.Empty)
{
return(NotFound());
}
return(Ok(result));
}
public LookupDto Get()
{
var entity = new LookupDto
{
Titles = _mapper.Map <List <TitleDto> >(Context.Titles.ToList()),
Genders = _mapper.Map <List <GenderDto> >(Context.Genders.ToList()),
Ethnicities = _mapper.Map <List <EthnicityDto> >(Context.Ethnicities.ToList()),
Nationalities = _mapper.Map <List <NationalityTypeDto> >(Context.NationalityTypes.ToList()),
Languages = _mapper.Map <List <LanguageDto> >(Context.Languages.ToList()),
DocumentTypes = _mapper.Map <List <DocumentTypeDto> >(Context.DocumentTypes.ToList()),
ContactByOptions = _mapper.Map <List <ContactByOptionDto> >(Context.ContactByOptions.ToList()),
Relationships = _mapper.Map <List <RelationshipDto> >(Context.Relationships.ToList()),
ContactTypes = _mapper.Map <List <ContactTypeDto> >(Context.ContactTypes.ToList())
};
return(entity);
}
public async Task <DocumentUpdateResultDto> CreateAsync(LookupDto dto)
{
await CheckForDuplicates(dto.GroupId, dto.Culture, dto.Section, dto.Key);
if (dto.Items != null)
{
CheckForCircularReference(dto.Key, dto.Items);
}
var lookup = new Lookup
{
Culture = dto.Culture,
Section = dto.Section,
Key = dto.Key,
IncludeInPod = dto.IncludeInPod,
Priority = ConfigurationHelper.GetConfigurationPriority(dto.GroupId, dto.Culture, dto.Section),
Items = CreateLookupItems(dto.Items),
};
var result = await _dataContext.CreateDocumentAsync(lookup);
return(result);
}
public async Task <DocumentUpdateResultDto> UpdateAsync(LookupDto dto)
{
var lookup = await _dataContext.GetDocumentAsync <Lookup>(dto.Id);
await CheckForDuplicates(dto.GroupId, dto.Culture, dto.Section, dto.Key, dto.Id);
if (dto.Items != null)
{
CheckForCircularReference(dto.Key, dto.Items);
}
lookup.Culture = dto.Culture;
lookup.Section = dto.Section;
lookup.Key = dto.Key;
lookup.IncludeInPod = dto.IncludeInPod;
lookup.Priority = ConfigurationHelper.GetConfigurationPriority(dto.GroupId, dto.Culture, dto.Section);
lookup.Items = CreateLookupItems(dto.Items);
lookup.ETag = dto.ETag;
var result = await _dataContext.ReplaceDocumentAsync(lookup);
return(result);
}
private void GetContactDetails(PersonDto contact, LookupDto lookUp)
{
var persistedContactDetailIds = contact.PersonContactDetails.Select(x => x.ContactByOptionId).ToList();
contact.ContactByOptions = lookUp.ContactByOptions.OrderBy(x => x.SortOrder).ToList();
foreach (var contactByOption in lookUp.ContactByOptions.Where(x => !persistedContactDetailIds.Contains(x.Id)).OrderBy(x => x.SortOrder).ToList())
{
contact.PersonContactDetails.Add(new PersonContactDetailDto {
ContactByOptionId = contactByOption.Id, ContactByOption = contactByOption
});
}
foreach (var contactDetail in contact.PersonContactDetails)
{
contactDetail.ContactByOption = lookUp.ContactByOptions.FirstOrDefault(x => x.Id == contactDetail.ContactByOptionId);
if (contactDetail.Id > 0)
{
contact.PersonContactDetails.First(x => x.ContactByOptionId == contactDetail.ContactByOptionId).ContactValue = contactDetail.ContactValue;
contact.PersonContactDetails.First(x => x.ContactByOptionId == contactDetail.ContactByOptionId).Comment = contactDetail.Comment;
contact.PersonContactDetails.First(x => x.ContactByOptionId == contactDetail.ContactByOptionId).IsSelected = true;
contact.PersonContactDetails.First(x => x.ContactByOptionId == contactDetail.ContactByOptionId).ContactByOption = lookUp.ContactByOptions.FirstOrDefault(x => x.Id == contactDetail.ContactByOptionId);
}
}
}
public async Task <LookupDto> GetAsync(string id)
{
var lookup = await _dataContext.GetDocumentAsync <Lookup>(id);
if (lookup == null)
{
return(null);
}
var dto = new LookupDto
{
Id = lookup.Id,
IsDeleted = lookup.IsDeleted,
Culture = lookup.Culture,
GroupId = lookup.GroupId,
Key = lookup.Key,
IncludeInPod = lookup.IncludeInPod,
Section = lookup.Section,
Priority = lookup.Priority,
UpdatedById = lookup.UpdatedById,
UpdatedByName = lookup.UpdatedByName,
UpdatedOnUtc = lookup.UpdatedOnUtc,
ETag = lookup.ETag,
Items = lookup.Items?
.Select(v => new LookupItemDto
{
Text = v.Text,
Value = v.Value,
Remark = v.Remark,
SortOrder = v.SortOrder,
ChildLookupKey = v.ChildLookupKey
}).ToList()
};
return(dto);
}
public async Task <DocumentUpdateResultDto> Put([FromBody] LookupDto dto)
{
var result = await _lookupService.UpdateAsync(dto);
return(result);
}
public async Task <IHttpActionResult> GetExpertiseLevelAsync(int id, CancellationToken cancellationToken = default(CancellationToken))
{
LookupDto expertiseLevel = await this.lookupService.GetExpertiseLevelAsync(id, cancellationToken);
return(this.Ok(expertiseLevel));
}
public async Task <IHttpActionResult> GetSkillAsync(int id, CancellationToken cancellationToken = default(CancellationToken))
{
LookupDto skill = await this.lookupService.GetSkillAsync(id, cancellationToken);
return(this.Ok(skill));
}
public FinderResults <ReportTemplateDto> ReportTemplateSearch(
int page,
int pageSize,
string reportType,
string search = null,
Guid?systemAccountKey = null,
Guid?patientKey = null)
{
var whereConstraintBuilder = new StringBuilder();
if (!string.IsNullOrWhiteSpace(search))
{
whereConstraintBuilder.Append(" AND (Name LIKE @search+'%')");
}
if (systemAccountKey != null)
{
whereConstraintBuilder.Append(" AND SystemAccountKey= @systemAccountKey ");
}
if (patientKey != null)
{
whereConstraintBuilder.Append(" AND PatientKey= @patientKey ");
}
else
{
whereConstraintBuilder.Append(" AND PatientKey IS NULL ");
}
const string Query = @"
SELECT COUNT(*) as TotalCount FROM ReportModule.ReportTemplate
WHERE ReportType = @ReportType {0}
SELECT [t].ReportStateCode,
[t].ReportTemplateKey AS 'Key',
[t].Name,
[t].Parameters,
[t].ReportType
FROM (
SELECT ROW_NUMBER() OVER (
ORDER BY [t1].Name) AS [ROW_NUMBER],
[t1].ReportStateCode,
[t1].ReportTemplateKey,
[t1].Name,
[t1].Parameters,
[t1].ReportType
FROM ReportModule.ReportTemplate AS [t1]
WHERE ReportType = @ReportType {0}
) AS [t]
WHERE [t].[ROW_NUMBER] BETWEEN @start + 1 AND @end
ORDER BY [t].[ROW_NUMBER] ";
var start = page * pageSize;
var end = start + pageSize;
var completeQuery = string.Format(Query, whereConstraintBuilder);
using (var connection = _connectionFactory.CreateConnection())
using (var multiQuery = connection.QueryMultiple(completeQuery, new { start, end, reportType, search, patientKey, systemAccountKey }))
{
var totalCount = multiQuery.Read <int> ().Single();
var reportTemplateDtos =
multiQuery.Read <string, ReportTemplateDto, ReportTemplateDto> (
(reportStateCode, reportTemplateDto) =>
{
var lookupDto = new LookupDto
{
Code = reportStateCode,
Name = _resourcesManager.GetResourceManagerByName("ReportState").GetString(reportStateCode),
};
reportTemplateDto.ReportState = lookupDto;
reportTemplateDto.ReportDisplayName = _resourcesManager.GetResourceManagerByName(reportTemplateDto.Name).GetString("ReportName");
return(reportTemplateDto);
},
"Key").ToList();
var finderResults = new FinderResults <ReportTemplateDto>
{
Data = reportTemplateDtos,
TotalCount = totalCount
};
return(finderResults);
}
}
public DataTableResponse <ReportTemplateDto> GetReportTemplatesForDataTable(
string sEcho,
int iDisplayStart,
int iDisplayLength,
string sSearch = null,
string systemAccountKey = null,
string organizationKey = null,
string reportType = null,
bool showAll = true)
{
var start = iDisplayStart;
var end = start + iDisplayLength;
const string ReportTemplateQuery = @"SELECT COUNT(*) as TotalCount FROM ReportModule.ReportTemplate
WHERE ReportType = @ReportType
AND PatientKey IS NULL
{0}
{1}
{2}
SELECT [t].ReportStateCode,
[t].ReportTemplateKey AS 'Key',
[t].SystemAccountKey,
[t].Name,
[t].Name AS 'ReportTypeName',
[t].Parameters,
[t].ReportType
FROM (
SELECT ROW_NUMBER() OVER (
ORDER BY [t1].Name) AS [ROW_NUMBER],
[t1].ReportStateCode,
[t1].ReportTemplateKey,
[t1].SystemAccountKey,
[t1].Name,
[t1].Name AS 'ReportTypeName',
[t1].Parameters,
[t1].ReportType
FROM ReportModule.ReportTemplate AS [t1]
WHERE ReportType = @ReportType
AND PatientKey IS NULL
{0}
{1}
{2}
) AS [t]
WHERE [t].[ROW_NUMBER] BETWEEN @start + 1 AND @end
ORDER BY [t].[ROW_NUMBER] ";
const string WhereConstraint = " AND (Name + Parameters LIKE '%' + replace(@search, ' ', '') + '%')";
var whereOrganizationKey = " AND OrganizationKey='" + organizationKey + "'";
var whereSystemAccountKey = string.IsNullOrWhiteSpace(systemAccountKey) || showAll ? string.Empty : " AND SystemAccountKey='" + systemAccountKey + "'";
var replaceString = string.IsNullOrWhiteSpace(sSearch) ? string.Empty : WhereConstraint;
var completeQuery = string.Format(ReportTemplateQuery, whereOrganizationKey, whereSystemAccountKey, replaceString);
using (var connection = _connectionFactory.CreateConnection())
using (var multiQuery = connection.QueryMultiple(completeQuery, new { start, end, search = sSearch, reportType, systemAccountKey }))
{
var totalCount = multiQuery.Read <int> ().Single();
var reportTemplateDtos =
multiQuery.Read <string, ReportTemplateDto, ReportTemplateDto> (
(reportStateCode, reportTemplateDto) =>
{
var lookupDto = new LookupDto
{
Code = reportStateCode,
Name = _resourcesManager.GetResourceManagerByName("ReportState").GetString(reportStateCode),
};
reportTemplateDto.ReportState = lookupDto;
var reportName = _resourcesManager.GetResourceManagerByName(reportTemplateDto.Name).GetString("ReportName");
reportTemplateDto.ReportTypeName = reportTemplateDto.Name;
reportTemplateDto.NameParameters = reportName + " " + reportTemplateDto.Parameters;
return(reportTemplateDto);
},
"Key").ToList();
var dataTableResponse = new DataTableResponse <ReportTemplateDto>
{
Data = reportTemplateDtos,
Echo = sEcho,
TotalDisplayRecords = totalCount,
TotalRecords = totalCount,
};
return(dataTableResponse);
}
}
public async Task <List <LookupDto> > GetStandardListsAsync()
{
var data = await _standardListRepository.ListAllAsync();
return(data.OrderBy(o => o.StandardListName).Select(s => LookupDto.From(s)).ToList());
}
public StringLookupItemViewModel(LookupDto item)
{
Id = item.Id.ToString();
Name = item.Name;
}
public LookupItemViewModel(LookupDto item)
{
Id = item.Id;
Name = item.Name;
}
private async Task CreateAsync(LookupDto input)
{
var lookup = ObjectMapper.Map <Lookup>(input);
await _lookupRepository.InsertAsync(lookup);
}
