public async Task <PagedList <Entity> > GetUserPermissions(UserPermissionQueryParameters userPermissionParameters)
{
var userPermissions = FindByCondition(x => x.IsDeleted == false && x.Role.Name != "Agent");
var filteredAgents = FilterUserPermissions(userPermissions, userPermissionParameters)
.Include(x => x.Role);
var sortedAgents = SortHelper.ApplySort(filteredAgents, userPermissionParameters.OrderBy);
var pagedAgents = sortedAgents;
if (!userPermissionParameters.SkipPageSize)
{
pagedAgents = sortedAgents
.Skip((userPermissionParameters.PageNumber - 1) * userPermissionParameters.PageSize)
.Take(userPermissionParameters.PageSize)
.Include(x => x.Role);
}
var mappedAgents = pagedAgents
.ProjectTo <UserPermissionDTO>(_mapper.ConfigurationProvider);
var shapedAgents = DataShaper.ShapeData(mappedAgents, userPermissionParameters.Fields);
return(await PagedList <Entity>
.ToPagedList(shapedAgents, filteredAgents.Count(), userPermissionParameters.PageNumber, userPermissionParameters.PageSize));
}
/// <summary>
/// Gets the scheduling codes.
/// </summary>
/// <param name="schedulingCodeParameters">The scheduling code parameters.</param>
/// <returns></returns>
public async Task <PagedList <Entity> > GetSchedulingCodes(SchedulingCodeQueryParameters schedulingCodeParameters)
{
var schedulingCodes = FindByCondition(x => x.IsDeleted == false);
var filteredSchedulingCodes = FilterSchedulingCodes(schedulingCodes, schedulingCodeParameters);
var sortedSchedulingCodes = SortHelper.ApplySort(filteredSchedulingCodes, schedulingCodeParameters.OrderBy);
var pagedSchedulingCodes = sortedSchedulingCodes;
if (!schedulingCodeParameters.SkipPageSize)
{
pagedSchedulingCodes = pagedSchedulingCodes
.Skip((schedulingCodeParameters.PageNumber - 1) * schedulingCodeParameters.PageSize)
.Take(schedulingCodeParameters.PageSize);
}
pagedSchedulingCodes = pagedSchedulingCodes
.Include(x => x.Icon)
.Include(x => x.SchedulingTypeCode)
.ThenInclude(x => x.SchedulingCodeType);
var mappedSchedulingCodes = pagedSchedulingCodes
.ProjectTo <SchedulingCodeDTO>(_mapper.ConfigurationProvider);
var shapedSchedulingCodes = DataShaper.ShapeData(mappedSchedulingCodes, schedulingCodeParameters.Fields);
return(await PagedList <Entity>
.ToPagedList(shapedSchedulingCodes, filteredSchedulingCodes.Count(), schedulingCodeParameters.PageNumber, schedulingCodeParameters.PageSize));
}
/// <summary>
/// Gets the agentCategories.
/// </summary>
/// <param name="agentCategoryParameters">The agentCategory parameters.</param>
/// <returns></returns>
public async Task <PagedList <Entity> > GetAgentCategories(AgentCategoryQueryParameter agentCategoryParameters)
{
var agentCategories = FindByCondition(x => x.IsDeleted == false);
var filteredAgentCategories = FilterAgentCategories(agentCategories, agentCategoryParameters);
var sortedAgentCategories = SortHelper.ApplySort(filteredAgentCategories, agentCategoryParameters.OrderBy);
var pagedAgentCategories = sortedAgentCategories;
if (!agentCategoryParameters.SkipPageSize)
{
pagedAgentCategories = sortedAgentCategories
.Skip((agentCategoryParameters.PageNumber - 1) * agentCategoryParameters.PageSize)
.Take(agentCategoryParameters.PageSize);
}
var mappedAgentCategories = pagedAgentCategories
.ProjectTo <AgentCategoryDTO>(_mapper.ConfigurationProvider);
var shapedAgentCategories = DataShaper.ShapeData(mappedAgentCategories, agentCategoryParameters.Fields);
return(await PagedList <Entity>
.ToPagedList(shapedAgentCategories, filteredAgentCategories.Count(), agentCategoryParameters.PageNumber, agentCategoryParameters.PageSize));
}
public EntityCacheGeneric <string, SettingItem> GetAllSettingItems(string name)
{
Type settingsType = this.GetType();
List <SettingItem> settingItems = new List <SettingItem>();
foreach (PropertyInfo p in settingsType.GetProperties())
{
object[] categoryAttributes = p.GetCustomAttributes(typeof(SettingInfoAttribute), true);
if (categoryAttributes == null)
{
continue;
}
foreach (SettingInfoAttribute c in categoryAttributes)
{
SettingItem settingItem = new SettingItem(
c.Category,
p.Name,
EntityReader.GetPropertyValue(p.Name, this, false),
p.PropertyType,
c.AutoFormatDisplayName,
c.DisplayName,
c.Description,
c.CategorySequenceId,
c.PasswordChar,
null,
new SettingsCategoryInfo(this, c.Category));
settingItems.Add(settingItem);
}
}
string entityCacheName = string.IsNullOrEmpty(name) ? DataShaper.ShapeCamelCaseString(this.GetType().Name) : name;
EntityCacheGeneric <string, SettingItem> result = new EntityCacheGeneric <string, SettingItem>(entityCacheName);
settingItems.OrderBy(p => p.Category).ToList().ForEach(p => result.Add(p.SettingName, p));
return(result);
}
public async Task <PagedList <Entity> > GetRoles(RoleQueryParameters roleParameters)
{
var roles = FindAll();
var filteredRoles = FilterRoles(roles, roleParameters);
var sortedRoles = SortHelper.ApplySort(filteredRoles, roleParameters.OrderBy);
var pagedRoles = sortedRoles;
if (!roleParameters.SkipPageSize)
{
pagedRoles = sortedRoles
.Skip((roleParameters.PageNumber - 1) * roleParameters.PageSize)
.Take(roleParameters.PageSize);
}
var mappedRoles = pagedRoles
.ProjectTo <RoleDTO>(_mapper.ConfigurationProvider);
var shapedRoles = DataShaper.ShapeData(mappedRoles, roleParameters.Fields);
return(await PagedList <Entity>
.ToPagedList(shapedRoles, filteredRoles.Count(), roleParameters.PageNumber, roleParameters.PageSize));
}
public PagedList <ShapedEntity> ListVotings()
{
List <Voting> votings = new List <Voting>
{
new Voting
{
Id = Guid.NewGuid(),
Name = ".NET",
CategoryId = Guid.NewGuid(),
DateCreated = new DateTime(),
Description = ".NET is a ecosystem that ...",
DueDate = new DateTime(),
VotersCount = 1,
Category = new Category(),
Users = new List <User>(),
UsersVotings = new List <UsersVotings>()
}
};
IDataShaper <Voting> dataShaper = new DataShaper <Voting>();
IEnumerable <ShapedEntity> shapedEntities = dataShaper.ShapeData(votings, "pageSize=10&pageNumber=1&orderBy=DueDate desc");
return(PagedList <ShapedEntity> .ToPagedList(shapedEntities, 1, 1));
}
public ICalPublicHoliday(
string eventName,
int year,
int month,
int day)
{
this.EventName = eventName;
this.DateIdentifier = DataShaper.GetDefaultDateString(new DateTime(year, month, day));
this.Year = year;
this.Month = month;
this.Day = day;
}
public override void AppendWhereColumns(List <WhereClauseColumnWindows> whereClause, bool appendWhereStatement)
{
if (appendWhereStatement)
{
_sqlQueryString.AppendLine("WHERE");
}
foreach (WhereClauseColumnWindows whereColumn in whereClause)
{
string whereColumnName = whereColumn.ColumnName;
if (whereColumn.IsCustomClause)
{
_sqlQueryString.AppendLine(whereColumn.ToString());
}
if (whereColumn.UseParameter)
{
string parameterName = string.Format("@{0}", DataShaper.GetUniqueIdentifier());
if (whereColumn.ComparisonOperator.Value == "IN")
{
parameterName = $"({parameterName})";
}
if (SqlParameterExists(_sqlParameters, parameterName))
{
throw new Exception(string.Format("Parameter with name {0} already added for where column {1}.", whereColumnName));
}
_sqlParameters.Add(new SQLiteParameter(parameterName, whereColumn.ColumnValue));
_sqlQueryString.Append(string.Format("[{0}] {1} {2}",
whereColumnName,
whereColumn.ComparisonOperator.ToString(),
parameterName));
}
else
{
string value = whereColumn.WrapValueWithQuotes ? $"'{whereColumn.ColumnValue}'" : $"{whereColumn.ColumnValue}";
if (whereColumn.ComparisonOperator.Value == "IN")
{
value = $"({value})";
}
_sqlQueryString.Append(string.Format("[{0}] {1} {2}", whereColumnName, whereColumn.ComparisonOperator.ToString(), value));
}
if (whereColumn.LogicalOperatorAgainstNextColumn == null)
{
_sqlQueryString.Append("");
break;
}
_sqlQueryString.Append(string.Format(" {0} ", whereColumn.LogicalOperatorAgainstNextColumn.ToString()));
}
whereClause.ForEach(w => _whereClause.Add(w));
}
private AnalyzerLogLine GetNextOriginatingLine(bool caseSensitive, int currentLineIndex, List <string> originatingVoiceCommandTextWords)
{
if ((currentLineIndex + 1) >= this.Count)
{
return(null); //After the end of the list.
}
currentLineIndex++;
while (currentLineIndex < this.Count)
{
if (DataShaper.StringContainsKeywords(this[currentLineIndex].VoiceCommand, caseSensitive, originatingVoiceCommandTextWords))
{
return(this[currentLineIndex]);
}
currentLineIndex++;
}
return(null);
}
public SettingItem(
string category,
string settingName,
object settingValue,
Type settingType,
bool autoFormatDisplayName,
string settingDisplayName,
string settingDescription,
int categorySequenceId,
char passwordChar,
SettingsControlWindows settingControl,
SettingsCategoryInfo settingsCategoryInfo)
{
_category = category;
_settingName = settingName;
_settingValue = settingValue;
_settingType = settingType;
_settingsCategoryInfo = settingsCategoryInfo;
if (string.IsNullOrEmpty(settingDisplayName))
{
_settingDisplayName = autoFormatDisplayName ? DataShaper.ShapeCamelCaseString(settingName) : settingName;
}
else
{
_settingDisplayName = settingDisplayName;
}
_settingDescription = settingDescription;
_categorySequenceId = categorySequenceId;
_passwordChar = passwordChar;
_listViewItem = new ListViewItem(_settingDisplayName);
if (_passwordChar != '\0')
{
_listViewItem.SubItems.Add(DataShaperWindows.MaskPasswordString(_settingValue.ToString(), _passwordChar));
}
else
{
_listViewItem.SubItems.Add(_settingValue != null ? _settingValue.ToString() : null);
}
_listViewItem.SubItems.Add(_settingDescription);
_listViewItem.Tag = this;
_settingControl = settingControl;
}
private AnalyzerLogLine GetOriginatingLine(bool caseSensitive, int currentLineIndex, List <string> originatingVoiceCommandTextWords)
{
if ((currentLineIndex - 1) < 0 || (originatingVoiceCommandTextWords == null))
{
return(null); //Before the beginning of the list.
}
currentLineIndex--;
while (currentLineIndex > -1) //Traverse back up the list to look for originating line causing the searchVoiceCommandText to be written.
{
string originatingValueToSearch = caseSensitive ? this[currentLineIndex].VoiceCommand : this[currentLineIndex].VoiceCommand.ToLower();
for (int k = 0; k < originatingVoiceCommandTextWords.Count; k++)
{
if (DataShaper.StringContainsKeywords(this[currentLineIndex].VoiceCommand, caseSensitive, originatingVoiceCommandTextWords))
{
return(this[currentLineIndex]);
}
}
currentLineIndex--;
}
return(null);
}
public EntityCacheGeneric <string, SettingItem> GetSettingsByCategory(SettingsCategoryInfo settingsCategoryInfo)
{
string categoryLower = settingsCategoryInfo.Category.Trim().ToLower();
Type settingsType = this.GetType();
List <SettingItem> settingItems = new List <SettingItem>();
foreach (PropertyInfo p in settingsType.GetProperties())
{
object[] categoryAttributes = p.GetCustomAttributes(typeof(SettingInfoAttribute), true);
if (categoryAttributes == null)
{
continue;
}
foreach (SettingInfoAttribute c in categoryAttributes)
{
if (c.Category.Trim().ToLower() == categoryLower)
{
SettingItem settingItem = new SettingItem(
c.Category,
p.Name,
EntityReader.GetPropertyValue(p.Name, this, false),
p.PropertyType,
c.AutoFormatDisplayName,
c.DisplayName,
c.Description,
c.CategorySequenceId,
c.PasswordChar,
null,
settingsCategoryInfo);
settingItems.Add(settingItem);
}
}
}
string entityCacheName = string.Format("{0} {1} Settings", DataShaper.ShapeCamelCaseString(settingsType.Name).Replace("Settings", "").Trim(), settingsCategoryInfo.Category);
EntityCacheGeneric <string, SettingItem> result = new EntityCacheGeneric <string, SettingItem>(entityCacheName);
settingItems.OrderBy(p => p.CategorySequenceId).ToList().ForEach(p => result.Add(p.SettingName, p));
return(result);
}
/// <summary>
/// Gets the language translations.
/// </summary>
/// <param name="languageTranslationQueryParameters">The language translation query parameters.</param>
/// <returns></returns>
public async Task <PagedList <Entity> > GetLanguageTranslations(LanguageTranslationQueryParameters languageTranslationQueryParameters)
{
var languages = FindByCondition(x => x.IsDeleted == false);
var filteredLanguages = FilterLanguages(languages, languageTranslationQueryParameters);
var sortedSchedulingCodes = SortHelper.ApplySort(filteredLanguages, languageTranslationQueryParameters.OrderBy);
var pagedLanguages = sortedSchedulingCodes
.Skip((languageTranslationQueryParameters.PageNumber - 1) * languageTranslationQueryParameters.PageSize)
.Take(languageTranslationQueryParameters.PageSize)
.Include(x => x.Language)
.Include(x => x.Menu)
.Include(x => x.Variable);
var mappedLanguages = pagedLanguages
.ProjectTo <LanguageTranslationDTO>(_mapper.ConfigurationProvider);
var shapedSchedulingCodes = DataShaper.ShapeData(mappedLanguages, languageTranslationQueryParameters.Fields);
return(await PagedList <Entity>
.ToPagedList(shapedSchedulingCodes, filteredLanguages.Count(), languageTranslationQueryParameters.PageNumber, languageTranslationQueryParameters.PageSize));
}
