public async Task <PagingModel <ProfileDto> > GetProfiles(ProfileFilter filter, int page, int pageSize)
{
Query baseQuery = new Query().From("Profiles");
if (filter != null)
{
baseQuery.WhereFilter(filter);
}
Query profilesQuery = baseQuery.Clone().Select("FirstName", "LastName", "MiddleName", "Birthday");
profilesQuery.Offset((page - 1) * pageSize);
profilesQuery.Limit(pageSize);
Query totalQuery = baseQuery.Clone().AsCount("Id");
SqlResult result = compiler.Compile(new Query[] { profilesQuery, totalQuery });
using (IDbConnection connection = dbConnectionFactory.CreateConnection())
{
using (SqlMapper.GridReader reader = await connection.QueryMultipleAsync(result.Sql, result.NamedBindings))
{
return(new PagingModel <ProfileDto>
{
Items = await reader.ReadAsync <ProfileDto>(),
Total = await reader.ReadSingleAsync <int>()
});
}
}
}
internal static void RemoveCategory(this ICategoryCache cache, ProfileFilter filter)
{
Ensure.Any.IsNotNull(cache, nameof(cache));
Ensure.Any.IsNotNull(filter, nameof(filter));
cache.RemoveCategory(filter.CategoryGroup, filter.CategoryName);
}
private static string BuildCategoryLinkCacheKey(ProfileFilter filter)
{
Debug.Assert(filter != null);
// The cache key has a prefix to partition this type of object just in case there is a key collision with another object type
return("CategoryLinks|" + filter.CategoryGroup + "|" + filter.CategoryName);
}
/// <summary>Creates the basic profile filter.</summary>
/// <param name="currentUser">The current user.</param>
/// <returns></returns>
private ProfileFilter CreateBasicProfileFilter(CurrentUser currentUser)
{
var filter = new ProfileFilter();
switch (currentUser.SexualOrientation)
{
case SexualOrientationType.Heterosexual:
filter.Gender = currentUser.Gender == GenderType.Male ? GenderType.Female : GenderType.Male;
break;
case SexualOrientationType.Homosexual:
filter.Gender = currentUser.Gender;
break;
case SexualOrientationType.Bisexual:
break;
case SexualOrientationType.Asexual:
break;
default:
filter.Gender = currentUser.Gender == GenderType.Male ? GenderType.Female : GenderType.Male;
break;
}
return(filter);
}
public void RemoveCategoryLinks(ProfileFilter filter)
{
Ensure.Any.IsNotNull(filter, nameof(filter));
var cacheKey = BuildCategoryLinkCacheKey(filter);
_cache.Remove(cacheKey);
}
public ICollection <Guid> GetCategoryLinks(ProfileFilter filter)
{
Ensure.Any.IsNotNull(filter, nameof(filter));
var cacheKey = BuildCategoryLinkCacheKey(filter);
return(_cache.Get <ICollection <Guid> >(cacheKey));
}
public void StoreCategoryLinks(ProfileFilter filter, ICollection <Guid> links)
{
Ensure.Any.IsNotNull(filter, nameof(filter));
Ensure.Any.IsNotNull(links, nameof(links));
var cacheKey = BuildCategoryLinkCacheKey(filter);
var options = new MemoryCacheEntryOptions
{
SlidingExpiration = _config.CategoryLinksExpiration
};
_cache.Set(cacheKey, links, options);
}
public IPagedList <ProfileViewModel> GetProfiles(ProfileFilter filter)
{
var profileViewModels = profiles;
if (!string.IsNullOrEmpty(filter.SearchString))
{
profileViewModels = profileViewModels
.Where(s => s.LastName.Contains(filter.SearchString) || s.FirstName.Contains(filter.SearchString));
}
SortProfiles(ref profileViewModels, filter.SortOrder);
return(profileViewModels.ToPagedList(filter.PageNumber, filter.PageCount));
}
public int GetProfilesTotalCount(ProfileFilter filter)
{
StringBuilder sb = new StringBuilder("SELECT DISTINCT COUNT(*) FROM profile pf INNER JOIN party pt ON pt.PartyId=pf.PartyId INNER JOIN profilerole pr ON pr.ProfileId=pf.ProfileId ");
AddWhereClause(filter, sb);
return(AppDbContext.Instance.Connection.ExecuteScalar <int>(sb.ToString(), new
{
UserId = filter.UserId.ToLikeEncodedParameter(),
Name = filter.Name.ToLikeEncodedParameter(),
LastName = filter.LastName.ToLikeEncodedParameter(),
MobileNumber = filter.MobileNumber.ToLikeEncodedParameter(),
Status = filter.Status,
RoleItemId = filter.RoleItemId,
}, AppDbContext.Instance.Transaction));
}
public async Task <IActionResult> SaveProfileFilter([FromBody] ProfileFilter profileFilter)
{
if (profileFilter == null)
{
return(BadRequest());
}
try
{
var currentUser = await _helper.GetCurrentUserProfile(User);
return(Ok(_currentUserRepository.SaveProfileFilter(currentUser, profileFilter)));
}
catch (Exception ex)
{
return(Problem(ex.ToString()));
}
}
public List <ProfileExt> GetProfiles(ProfileFilter filter, int?page, int?pageSize)
{
StringBuilder sb = new StringBuilder("SELECT DISTINCT * FROM profile pf INNER JOIN party pt ON pt.PartyId=pf.PartyId INNER JOIN profilerole pr ON pr.ProfileId=pf.ProfileId ");
AddWhereClause(filter, sb);
sb.Append("ORDER BY CreationDate LIMIT @FromPage, @PageSize");
return(AppDbContext.Instance.Connection.Query <ProfileExt>(sb.ToString(), new
{
UserId = filter.UserId.ToLikeEncodedParameter(),
Name = filter.Name.ToLikeEncodedParameter(),
LastName = filter.LastName.ToLikeEncodedParameter(),
MobileNumber = filter.MobileNumber.ToLikeEncodedParameter(),
Status = filter.Status,
RoleItemId = filter.RoleItemId,
PageSize = pageSize.ToPageSizeNormalize(),
FromPage = page.ToPageNormalize() * pageSize.ToPageSizeNormalize()
}, AppDbContext.Instance.Transaction).ToList());
}
public async Task <PagingModel <ProfileDto> > GetAll(int page, int pageSize, string filter = null)
{
try
{
ProfileFilter profileFilter = null;
if (filter != null)
{
profileFilter = JsonSerializer.Deserialize <ProfileFilter>(filter);
}
return(await profilesRepository.GetProfiles(profileFilter, page, pageSize));
}
catch (System.Exception)
{
throw;
}
}
public IActionResult Profiles(string searchString = "", SortState sortOrder = SortState.LastNameAsc, int page = 1, int pageCount = 3)
{
ProfileFilter profileFilter = new ProfileFilter
{
SearchString = searchString,
SortOrder = sortOrder,
PageNumber = page,
PageCount = pageCount
};
var formatProfileViewModel = new FormatProfileViewModel
{
ProfileFilter = profileFilter,
Profiles = profileService.GetProfiles(profileFilter)
};
return(View(formatProfileViewModel));
}
public Task BindModelAsync(ModelBindingContext bindingContext)
{
if (bindingContext == null)
{
throw new ArgumentNullException(nameof(bindingContext));
}
var filters = new List <ProfileFilter>();
var queries = bindingContext.HttpContext.Request.Query;
foreach (var query in queries)
{
CategoryGroup categoryGroup;
if (Enum.TryParse(query.Key, true, out categoryGroup) == false)
{
continue;
}
foreach (var value in query.Value)
{
if (string.IsNullOrWhiteSpace(value))
{
continue;
}
// This appears to be a valid filter
var filter = new ProfileFilter
{
CategoryGroup = categoryGroup,
CategoryName = value
};
filters.Add(filter);
}
}
//bindingContext.ModelState.SetModelValue(bindingContext.ModelName, result);
bindingContext.Result = ModelBindingResult.Success(filters);
return(Task.CompletedTask);
}
private void AddWhereClause(ProfileFilter filter, StringBuilder sb)
{
//default where clause
sb.Append("WHERE 1 ");
//UserId
if (!string.IsNullOrEmpty(filter.UserId))
{
sb.Append("AND pf.UserId LIKE @UserId ");
}
//Name
if (!string.IsNullOrEmpty(filter.Name))
{
sb.Append("AND pt.Name LIKE @Name ");
}
//LastName
if (!string.IsNullOrEmpty(filter.LastName))
{
sb.Append("AND pt.LastName LIKE @LastName ");
}
//MobileNumber
if (!string.IsNullOrEmpty(filter.MobileNumber))
{
sb.Append("AND pf.MobileNumber LIKE @MobileNumber ");
}
//Status
if (!string.IsNullOrEmpty(filter.Status))
{
sb.Append("AND pf.Status=@Status ");
}
//RoleItemId
if (filter.RoleItemId.HasValue)
{
sb.Append("AND pr.RoleItemId=@RoleItemId ");
}
}
/// <summary>Saves the profile filter to currentUser.</summary>
/// <param name="currentUser">The current user.</param>
/// <param name="profileFilter">The profile filter.</param>
/// <returns></returns>
public async Task <CurrentUser> SaveProfileFilter(CurrentUser currentUser, ProfileFilter profileFilter)
{
try
{
var filter = Builders <CurrentUser>
.Filter.Eq(p => p.ProfileId, currentUser.ProfileId);
var update = Builders <CurrentUser>
.Update.Set(p => p.ProfileFilter, profileFilter);
var options = new FindOneAndUpdateOptions <CurrentUser>
{
ReturnDocument = ReturnDocument.After
};
return(await _context.CurrentUser.FindOneAndUpdateAsync(filter, update, options));
}
catch (Exception ex)
{
throw ex;
}
}
private async Task <ICollection <Guid> > GetCategoryLinks(
ProfileFilter filter,
CancellationToken cancellationToken)
{
var cachedLinks = _cache.GetCategoryLinks(filter);
if (cachedLinks != null)
{
return(cachedLinks);
}
var storedLinks =
(await _linkStore.GetCategoryLinks(filter.CategoryGroup, filter.CategoryName, cancellationToken)
.ConfigureAwait(false)).ToList();
var links = (from x in storedLinks
select x.ProfileId).ToList();
_cache.StoreCategoryLinks(filter, links);
return(links);
}
static void Main(string[] args)
{
ProfileServiceClient client = new ProfileServiceClient("WSHttpBinding_ProfileService");
// AddProfile
Profile newProfile = new Profile()
{
Username = "******",
Password = "******",
Name = "Guillermo",
Surname = "Schlereth Lamas",
Email = "*****@*****.**",
DateOfBirth = DateTime.Parse("12/06/1972"),
Description = "Hola soy Guillermo",
Gender = Gender.Male,
Address = new Address() { Street = "Federico Mompou, 3", City = "Torremolinos", PostalCode = "29620" }
};
Guid guilleID = client.AddProfile(newProfile);
newProfile = new Profile()
{
Username = "******",
Password = "******",
Name = "Lidia",
Surname = "Lluch Fuentes",
Email = "*****@*****.**",
DateOfBirth = DateTime.Parse("21/07/1973"),
Description = "Hola soy Lidia",
Gender = Gender.Female,
Address = new Address() { Street = "Federico Mompou, 3", City = "Torremolinos", PostalCode = "29620" }
};
Guid lidiaID = client.AddProfile(newProfile);
newProfile = new Profile()
{
Username = "******",
Password = "******",
Name = "Liam",
Surname = "Schlereth Lluch",
Email = "*****@*****.**",
DateOfBirth = DateTime.Parse("25/03/2008"),
Description = "Hola soy Liam",
Gender = Gender.Male,
Address = new Address() { Street = "Federico Mompou, 3", City = "Torremolinos", PostalCode = "29620" }
};
Guid liamID = client.AddProfile(newProfile);
// CreateProfile
Guid sergioID = client.CreateProfile("sergio", "admin123", "*****@*****.**", "Sergio", "Schlereth Lamas");
Guid mariaID = client.CreateProfile("mariluz", "admin123", "*****@*****.**", "Mariluz", "Schlereth Lamas");
Guid pericoID = client.CreateProfile("perico", "admin123", "*****@*****.**", "Pedro", "Delgado");
// GetAllProfiles
List<Profile> allProfiles = client.GetAllProfiles();
WriteProfiles(allProfiles, "All profiles -->");
// GetProfileByID and GetProfileByCredentials
Profile liamProfile = client.GetProfileByID(liamID);
Profile sergioProfile = client.GetProfileByID(sergioID);
Profile lidiaProfile = client.GetProfileByCredentials("lidia", "admin123");
List<Profile> selectProfiles = new List<Profile>();
selectProfiles.Add(liamProfile);
selectProfiles.Add(sergioProfile);
selectProfiles.Add(lidiaProfile);
WriteProfiles(selectProfiles, "Liam, Sergio and Lidia profiles -->");
// ModifyProfile
sergioProfile.Description = "Hola soy Sergio ...";
sergioProfile.Email = "*****@*****.**";
sergioProfile.DateOfBirth = DateTime.Parse("25/06/1986");
sergioProfile.Gender = Gender.Male;
sergioProfile.Address = new Address
{
Street = "Avda. Bellamina, 3",
City = "Torremolinos",
PostalCode = "29620"
};
client.ModifyProfile(sergioProfile);
WriteProfiles(new List<Profile>() { client.GetProfileByID(sergioID) }, "Sergio profile modified -->");
// DeleteProfile
client.DeleteProfile(pericoID);
WriteProfiles(client.GetAllProfiles(), "Perico profile deleted -->");
// SearchProfiles
ProfileFilter filter = new ProfileFilter()
{
Street = "Mompou"
};
List<Profile> searchResult = client.SearchProfiles(filter);
WriteProfiles(searchResult, "Profiles living in Mompou street -->");
// AddContact
client.AddContact(guilleID, lidiaID);
client.AddContact(guilleID, liamID);
// AddContacts
client.AddContacts(guilleID, new List<Guid>() { sergioID, mariaID });
// GetContacts
WriteProfiles(client.GetContacts(guilleID), "Guille contacts -->");
// RemoveContact
client.RemoveContact(guilleID, sergioID);
WriteProfiles(client.GetContacts(guilleID), "Sergio removed from guille contacts -->");
// RemoveAllContacts
client.RemoveAllContacts(guilleID);
WriteProfiles(client.GetContacts(guilleID), "Guille contacts removed -->");
// Delete Profiles
client.DeleteProfile(guilleID);
client.DeleteProfile(lidiaID);
client.DeleteProfile(sergioID);
client.DeleteProfile(mariaID);
client.DeleteProfile(liamID);
WriteProfiles(client.GetAllProfiles(), "All contacts deleted -->");
Console.ReadLine();
}
private async Task UpdateCategories(
Profile profile,
ProfileChangeResult changes,
CancellationToken cancellationToken)
{
var cacheItemsToRemove = new List <ProfileFilter>();
// Get the current categories
var categories =
(await _categoryStore.GetAllCategories(cancellationToken).ConfigureAwait(false)).FastToList();
var categoryTasks = new List <Task>();
// Write all category link changes
foreach (var categoryChange in changes.CategoryChanges)
{
// Get the category
var category = categories.FirstOrDefault(
x => x.Group == categoryChange.CategoryGroup && x.Name.Equals(
categoryChange.CategoryName,
StringComparison.OrdinalIgnoreCase));
if (category == null)
{
// We haven't seen this category before
category = new Category
{
Group = categoryChange.CategoryGroup,
LinkCount = 0,
Name = categoryChange.CategoryName,
Reviewed = false,
Visible = false
};
// Trigger a notification that a new category is being added to the system
var newCategoryTriggerTask = _eventTrigger.NewCategory(category, cancellationToken);
categoryTasks.Add(newCategoryTriggerTask);
categories.Add(category);
}
if (categoryChange.ChangeType == CategoryLinkChangeType.Add)
{
// This is a new link between the profile and the category
category.LinkCount++;
}
else
{
// We are removing the link between the profile and the category
category.LinkCount--;
}
var change = new CategoryLinkChange
{
ChangeType = categoryChange.ChangeType,
ProfileId = profile.Id
};
// Store the link update
var categoryLinkTask = _linkStore.StoreCategoryLink(
category.Group,
category.Name,
change,
cancellationToken);
categoryTasks.Add(categoryLinkTask);
var filter = new ProfileFilter
{
CategoryGroup = category.Group,
CategoryName = category.Name
};
cacheItemsToRemove.Add(filter);
// Update the category data
var categoryTask = _categoryStore.StoreCategory(category, cancellationToken);
categoryTasks.Add(categoryTask);
}
// Run all the category task changes together
await Task.WhenAll(categoryTasks).ConfigureAwait(false);
UpdateCacheStore(categories, cacheItemsToRemove);
}
// Search for anything in filter - eg. { Body: 'something' }
/// <summary>Gets the profile by filter.</summary>
/// <param name="filter">The filter.</param>
/// <param name="orderByType">The OrderByDescending column type.</param>
/// <returns></returns>
public async Task <IEnumerable <Profile> > GetProfileByFilter(CurrentUser currentUser, ProfileFilter profileFilter, OrderByType orderByType, int skip, int limit)
{
try
{
List <FilterDefinition <Profile> > filters = new List <FilterDefinition <Profile> >();
//Remove currentUser from the list.
filters.Add(Builders <Profile> .Filter.Ne(p => p.ProfileId, currentUser.ProfileId));
//Add basic search criteria.
filters.Add(Builders <Profile> .Filter.Eq(p => p.SexualOrientation, currentUser.SexualOrientation));
filters.Add(Builders <Profile> .Filter.Eq(p => p.Gender, profileFilter.Gender));
//Apply all other ProfileFilter criterias.
filters = this.ApplyProfileFilter(profileFilter, filters);
var combineFilters = Builders <Profile> .Filter.And(filters);
switch (orderByType)
{
case OrderByType.CreatedOn:
return(_context.Profiles
.Find(combineFilters).Skip(skip).Limit(limit).ToList().OrderByDescending(p => p.CreatedOn));
case OrderByType.UpdatedOn:
return(_context.Profiles
.Find(combineFilters).Skip(skip).Limit(limit).ToList().OrderByDescending(p => p.UpdatedOn));
case OrderByType.LastActive:
return(_context.Profiles
.Find(combineFilters).Skip(skip).Limit(limit).ToList().OrderByDescending(p => p.UpdatedOn));
default:
return(_context.Profiles
.Find(combineFilters).Skip(skip).Limit(limit).ToList().OrderByDescending(p => p.CreatedOn));
}
}
catch (Exception ex)
{
throw ex;
}
}
public virtual int GetProfilesTotalCount(ProfileFilter profile)
{
return(profileRepo.GetProfilesTotalCount(profile));
}
public virtual List <ProfileExt> GetProfiles(ProfileFilter filter, int?page, int?pageSize)
{
return(profileRepo.GetProfiles(filter, page, pageSize));
}
private List <FilterDefinition <Profile> > ApplyProfileFilter(ProfileFilter profileFilter, List <FilterDefinition <Profile> > filters)
{
try
{
if (profileFilter.Name != null)
{
filters.Add(Builders <Profile> .Filter.Regex(p => p.Name, new BsonRegularExpression(profileFilter.Name, "i")));
}
if (profileFilter.Age != null && profileFilter.Age[0] > 0)
{
filters.Add(Builders <Profile> .Filter.Gte(p => p.Age, profileFilter.Age[0]));
}
if (profileFilter.Age != null && profileFilter.Age[1] > 0)
{
filters.Add(Builders <Profile> .Filter.Lte(p => p.Age, profileFilter.Age[1]));
}
if (profileFilter.Height != null && profileFilter.Height[0] > 0)
{
filters.Add(Builders <Profile> .Filter.Gte(p => p.Height, profileFilter.Height[0]));
}
if (profileFilter.Height != null && profileFilter.Height[1] > 0)
{
filters.Add(Builders <Profile> .Filter.Lte(p => p.Height, profileFilter.Height[1]));
}
if (profileFilter.Description != null)
{
filters.Add(Builders <Profile> .Filter.Regex(p => p.Description, new BsonRegularExpression(profileFilter.Description, "i")));
}
if (profileFilter.Tags != null && profileFilter.Tags.Count > 0)
{
filters.Add(Builders <Profile> .Filter.AnyIn(p => p.Tags, profileFilter.Tags));
}
if (profileFilter.Body != BodyType.NotChosen)
{
filters.Add(Builders <Profile> .Filter.Eq(p => p.Body, profileFilter.Body));
}
if (profileFilter.SmokingHabits != SmokingHabitsType.NotChosen)
{
filters.Add(Builders <Profile> .Filter.Eq(p => p.SmokingHabits, profileFilter.SmokingHabits));
}
if (profileFilter.HasChildren != HasChildrenType.NotChosen)
{
filters.Add(Builders <Profile> .Filter.Eq(p => p.HasChildren, profileFilter.HasChildren));
}
if (profileFilter.WantChildren != WantChildrenType.NotChosen)
{
filters.Add(Builders <Profile> .Filter.Eq(p => p.WantChildren, profileFilter.WantChildren));
}
if (profileFilter.HasPets != HasPetsType.NotChosen)
{
filters.Add(Builders <Profile> .Filter.Eq(p => p.HasPets, profileFilter.HasPets));
}
if (profileFilter.LivesIn != LivesInType.NotChosen)
{
filters.Add(Builders <Profile> .Filter.Eq(p => p.LivesIn, profileFilter.LivesIn));
}
if (profileFilter.Education != EducationType.NotChosen)
{
filters.Add(Builders <Profile> .Filter.Eq(p => p.Education, profileFilter.Education));
}
if (profileFilter.EducationStatus != EducationStatusType.NotChosen)
{
filters.Add(Builders <Profile> .Filter.Eq(p => p.EducationStatus, profileFilter.EducationStatus));
}
if (profileFilter.EmploymentStatus != EmploymentStatusType.NotChosen)
{
filters.Add(Builders <Profile> .Filter.Eq(p => p.EmploymentStatus, profileFilter.EmploymentStatus));
}
if (profileFilter.SportsActivity != SportsActivityType.NotChosen)
{
filters.Add(Builders <Profile> .Filter.Eq(p => p.SportsActivity, profileFilter.SportsActivity));
}
if (profileFilter.EatingHabits != EatingHabitsType.NotChosen)
{
filters.Add(Builders <Profile> .Filter.Eq(p => p.EatingHabits, profileFilter.EatingHabits));
}
if (profileFilter.ClotheStyle != ClotheStyleType.NotChosen)
{
filters.Add(Builders <Profile> .Filter.Eq(p => p.ClotheStyle, profileFilter.ClotheStyle));
}
if (profileFilter.BodyArt != BodyArtType.NotChosen)
{
filters.Add(Builders <Profile> .Filter.Eq(p => p.BodyArt, profileFilter.BodyArt));
}
return(filters);
}
catch (Exception ex)
{
throw ex;
}
}
