private static void FindPreferences(
IEnumerable <ApplicationUser> genderToFindPreferencesFor,
IEnumerable <ApplicationUser> genderToPreference,
out List <PreferenceModel> preferenceModels)
{
preferenceModels = new List <PreferenceModel>();
var partnerIds = genderToPreference.Select(x => x.Id).ToList();
foreach (var dancer in genderToFindPreferencesFor)
{
var preferenceModel = new PreferenceModel(dancer.Id);
var partnersNotYetDancedWith = partnerIds
.Where(x => !dancer.FormerMatches.Exists(y => y.PartnerId == x));
foreach (var partner in partnersNotYetDancedWith)
{
preferenceModel.PreferenceOrder.Add(partner);
}
var partnersDancedWithAscending =
dancer.FormerMatches
.GroupBy(x => x.PartnerId)
.Select(x => new { Id = x.Key, Count = x.Count() })
.OrderBy(x => x.Count);
foreach (var partner in partnersDancedWithAscending)
{
preferenceModel.PreferenceOrder.Add(partner.Id);
}
preferenceModels.Add(preferenceModel);
}
}
public string ChangePassword(PreferenceModel pref)
{
uas_User user = pref.db.uas_User.Where(u => u.UserID == SessionHelper.LoginStatus.UserID).FirstOrDefault();
try
{
string encryptedNewPassword = UtilityFunction.EncryptPassword(pref.NewPasswordOne);
user.Password = encryptedNewPassword;
user.ModifiedBy = SessionHelper.LoginStatus.UserID;
user.ModifiedDate = DateTime.Now;
pref.db.Entry(user).State = System.Data.Entity.EntityState.Modified;
pref.db.SaveChanges();
}
catch (Exception ex) {
Debug.Write("Change password: "******"Change password: Error changing if force change password.");
}
}
return("success");
}
public async Task <IActionResult> OnGetAsync()
{
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound($"Unable to load user with ID '{_userManager.GetUserId(User)}'."));
}
//Preferences info
preferenceModel = new PreferenceModel
{
platformPreferences = await _context.PlatformPreference
.Include(g => g.PlatformCodeNavigation)
.Where(g => g.UserId == user.Id)
.OrderBy(a => a.LastModified)
.ToListAsync(),
categoryPreferences = await _context.CategoryPreference
.Include(g => g.Gamecategory)
.Where(g => g.UserId == user.Id)
.OrderBy(a => a.LastModified)
.ToListAsync(),
subCategoryPreferences = await _context.SubCategoryPreference
.Include(g => g.GameSubcategory)
.Where(g => g.UserId == user.Id)
.OrderBy(a => a.LastModified)
.ToListAsync()
};
return(Page());
}
public override async Task <PreferenceModel> UpdatePreference(UpdatePreferenceRequest request, ServerCallContext context)
{
Preference preference = _mapper.Map <Preference>(request.Preference);
bool isExist = await _preferenceRepository.Get(x => x.Id == request.Preference.Id).AnyAsync();
if (!isExist)
{
throw new RpcException(new Status(StatusCode.NotFound, $"Preference with ID={preference.Id} is not found."));
}
try
{
_preferenceRepository.Update(preference);
await _preferenceRepository.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
throw;
}
PreferenceModel preferenceModel = _mapper.Map <PreferenceModel>(preference);
return(preferenceModel);
}
public ActionResult Index(PreferenceModel pref)
{
if (!SessionHelper.IsUserLoggedIn)
{
return(RedirectToAction("Index", "Account"));
}
return(View("_Preferences2", pref));
}
public ActionResult indexPassword(PreferenceModel pref)
{
if (!SessionHelper.IsUserLoggedIn)
{
return(RedirectToAction("Index", "Account"));
}
if (NeedChangePassword(SessionHelper.LoginStatus.UserID))
{
pref.ChangePass = true;
}
return(View("_Preferences3", pref));
}
public string checkOldPass(PreferenceModel pref)
{
uas_User user = pref.db.uas_User.Where(u => u.UserID == SessionHelper.LoginStatus.UserID).FirstOrDefault();
if (UtilityFunction.EncryptPassword(pref.Password) == user.Password)
{
return("success");
}
else if (String.IsNullOrEmpty(user.Password) && user.ChangePassword && UtilityFunction.EncryptPassword(pref.Password) == user.TempPassword)
{
return("success");
}
return("fail");
}
private uas_ProfileConfig newProfileConfig(PreferenceModel pref, uas_Config config)
{
uas_ProfileConfig profileConfig = new uas_ProfileConfig();
profileConfig.ConfigID = config.ConfigID;
profileConfig.ProfileSet = null;
pref.db.uas_ProfileConfig.Add(profileConfig);
pref.db.SaveChanges();
profileConfig = pref.db.uas_ProfileConfig.Where(p => p.ConfigID == config.ConfigID).FirstOrDefault();
return(profileConfig);
}
private uas_Config newConfig(PreferenceModel pref)
{
uas_Config config = new uas_Config();
config.ConfigName = "NoGridAssmnts";
config.ConfigParams = "number";
pref.db.uas_Config.Add(config);
pref.db.SaveChanges();
config = pref.db.uas_Config.Where(c => c.ConfigName == "NoGridAssmnts").FirstOrDefault();
return(config);
}
private void newUserProfile(PreferenceModel pref, uas_ProfileConfig profileConfig)
{
uas_UserProfile userProfile = new uas_UserProfile();
userProfile.ProfileConfigID = profileConfig.ProfileConfigID;
userProfile.UserID = SessionHelper.LoginStatus.UserID;
userProfile.OptionSet = pref.numAssmnts;
userProfile.SortOrder = 0;
userProfile.StatusFlag = "A";
userProfile.CreatedBy = SessionHelper.LoginStatus.UserID;
userProfile.CreatedDate = DateTime.Now;
pref.db.uas_UserProfile.Add(userProfile);
pref.db.SaveChanges();
}
private async void ExecuteSaveCommand()
{
try
{
if (string.IsNullOrWhiteSpace(SelectedTags) && SelectedCategory == null)
{
await DisplayAlert("Atenção", "Informe uma Categoria e/ou TAGs", "OK");
return;
}
var confirm = await DisplayAlert("Atenção", "Deseja adicionar a preferência?", "Sim", "Não");
if (!confirm)
{
return;
}
IsBusy = true;
await Task.Delay(100).ConfigureAwait(true);
var preference = new PreferenceModel
{
CategoryId = SelectedCategory?.Id,
Id = Guid.NewGuid().ToString(),
Tag = SelectedTags,
UserId = Settings.UserId
};
await _client.Save(preference);
SelectedCategory = null;
SelectedTags = null;
await LoadPreferencesAsync();
}
catch (Exception ex)
{
await DisplayAlert("Erro", ex.Message, "OK");
}
finally
{
IsBusy = false;
}
}
public ActionResult ChangeNum(PreferenceModel pref)
{
uas_Config config = pref.db.uas_Config.Where(c => c.ConfigName == "NoGridAssmnts").FirstOrDefault();
if (config != null)
{
uas_ProfileConfig profileConfig = pref.db.uas_ProfileConfig.Where(p => p.ConfigID == config.ConfigID).FirstOrDefault();
if (profileConfig != null)
{
uas_UserProfile userProfile = pref.db.uas_UserProfile.Where(u => u.ProfileConfigID == profileConfig.ProfileConfigID &&
u.UserID == SessionHelper.LoginStatus.UserID).FirstOrDefault();
if (userProfile != null)
{
userProfile.OptionSet = pref.numAssmnts;
userProfile.ModifiedBy = SessionHelper.LoginStatus.UserID;
userProfile.ModifiedDate = DateTime.Now;
pref.db.Entry(userProfile).State = System.Data.Entity.EntityState.Modified;
pref.db.SaveChanges();
}
else
{
newUserProfile(pref, profileConfig);
}
}
else
{
profileConfig = newProfileConfig(pref, config);
newUserProfile(pref, profileConfig);
}
}
else
{
config = newConfig(pref);
uas_ProfileConfig profileConfig = newProfileConfig(pref, config);
newUserProfile(pref, profileConfig);
}
return(RedirectToAction("Index", "Search"));
}
public override async Task GetAllPreferences(GetAllPreferencesRequest request,
IServerStreamWriter <PreferenceModel> responseStream,
ServerCallContext context)
{
try
{
List <Preference> preferences = await _preferenceRepository.GetNoTracking().ToListAsync();
foreach (var preference in preferences)
{
PreferenceModel preferenceModel = _mapper.Map <PreferenceModel>(preference);
await responseStream.WriteAsync(preferenceModel);
}
}
catch (Exception)
{
throw;
}
}
public override async Task <PreferenceModel> GetPreference(GetPreferenceRequest request,
ServerCallContext context)
{
try
{
Preference preference = await _preferenceRepository.GetNoTracking(x => x.Id == request.Id).FirstOrDefaultAsync();
if (preference == null)
{
throw new RpcException(new Status(StatusCode.NotFound, $"Preference with ID={request.Id} is not found."));
}
PreferenceModel preferenceModel = _mapper.Map <PreferenceModel>(preference);
return(preferenceModel);
}
catch (Exception)
{
throw new RpcException(new Status(StatusCode.NotFound, $"Preference with ID={request.Id} is not found."));
}
}
/// <summary>
/// Sets the object for key.
/// </summary>
/// <param name="key">Key.</param>
/// <param name="value">Value.</param>
/// <typeparam name="T">The 1st type parameter.</typeparam>
private void SetObjectForKey <T>(T value, [CallerMemberName] string propertyName = null)
{
var key = propertyName;
var json = JsonConvert.SerializeObject(value);
if (!_cache.ContainsKey(key))
{
// create new model
var item = new PreferenceModel {
Id = key, ValueAsJSON = json
};
// Add to cache
_cache.Add(key, item);
// Add to the repo
_preferenceModelRepository.Insert(item);
}
else
{
// Update in cache
var item = _cache[key];
item.ValueAsJSON = json;
}
// Persist after a number of updates
if (_updateCount > 20)
{
Task.Run(async() => await PersistAsync()).Wait();
_updateCount = 0;
}
else
{
_updateCount++;
}
_loggingService.Log(LogLevel.Verbose, this, "SetObject(key={0}, value={1})", key, value);
}
public ActionResult indexUser(PreferenceModel pref)
{
uas_Config config = pref.db.uas_Config.Where(c => c.ConfigName == "NoGridAssmnts").FirstOrDefault();
if (config != null)
{
uas_ProfileConfig profileConfig = pref.db.uas_ProfileConfig.Where(p => p.ConfigID == config.ConfigID).FirstOrDefault();
if (profileConfig != null)
{
uas_UserProfile userProfile = pref.db.uas_UserProfile.Where(u => u.ProfileConfigID == profileConfig.ProfileConfigID &&
u.UserID == SessionHelper.LoginStatus.UserID).FirstOrDefault();
if (userProfile != null)
{
pref.numAssmnts = userProfile.OptionSet;
}
}
}
return(View("_Preferences1", pref));
}
public PartialViewResult Partial(PreferenceModel pref)
{
return(PartialView("_Preferences2", pref));
}
public string Save(PreferenceModel pref)
{
Debug.WriteLine("PreferencesController.Save from form - first last:" + pref.user.FirstName + " " + pref.user.LastName);
Debug.WriteLine("PreferencesController.Save address: " + pref.address.Address1);
if (!SessionHelper.IsUserLoggedIn)
{
return("User not logged in");
}
uas_User user = pref.db.uas_User.Where(u => u.UserID == SessionHelper.LoginStatus.UserID).FirstOrDefault();
uas_UserPhone userPhone = pref.db.uas_UserPhone.Where(u => u.UserID == SessionHelper.LoginStatus.UserID).FirstOrDefault();
uas_UserAddress userAddress = pref.db.uas_UserAddress.Where(u => u.UserID == SessionHelper.LoginStatus.UserID).FirstOrDefault();
uas_UserEmail userEmail = pref.db.uas_UserEmail.Where(u => u.UserID == SessionHelper.LoginStatus.UserID).FirstOrDefault();
user.FirstName = pref.user.FirstName;
user.LastName = pref.user.LastName;
user.MiddleName = pref.user.MiddleName;
user.Title = pref.user.Title;
user.Area = pref.user.Area;
userPhone.PhoneNumber = pref.phone.PhoneNumber;
userPhone.Extension = pref.phone.Extension;
userAddress.Address1 = pref.address.Address1;
userAddress.City = pref.address.City;
userAddress.StateProvince = pref.address.StateProvince;
userAddress.PostalCode = pref.address.PostalCode;
userEmail.EmailAddress = pref.email.EmailAddress;
user.ModifiedBy = SessionHelper.LoginStatus.UserID;
user.ModifiedDate = DateTime.Now;
userPhone.ModifiedBy = SessionHelper.LoginStatus.UserID;
userPhone.ModifiedDate = DateTime.Now;
userAddress.ModifiedBy = SessionHelper.LoginStatus.UserID;
userAddress.ModifiedDate = DateTime.Now;
userEmail.ModifiedBy = SessionHelper.LoginStatus.UserID;
userEmail.ModifiedDate = DateTime.Now;
pref.db.Entry(user).State = System.Data.Entity.EntityState.Modified;
pref.db.Entry(userAddress).State = System.Data.Entity.EntityState.Modified;
pref.db.Entry(userPhone).State = System.Data.Entity.EntityState.Modified;
pref.db.Entry(userEmail).State = System.Data.Entity.EntityState.Modified;
pref.user = user;
pref.address = userAddress;
pref.phone = userPhone;
pref.email = userEmail;
try
{
pref.db.SaveChanges();
}
catch (DbEntityValidationException dbEx)
{
Debug.WriteLine("Save DbEntityValidation Exception: ");
string errors = "";
foreach (DbEntityValidationResult devr in dbEx.EntityValidationErrors)
{
foreach (DbValidationError dve in devr.ValidationErrors)
{
Debug.WriteLine(" DbEntityValidationResult: " + dve.ErrorMessage);
errors += dve.ErrorMessage + "<br />";
}
}
return(errors);
}
catch (System.Data.DataException de)
{
Debug.WriteLine("Save DataException: " + de.Message);
return(de.Message);
}
catch (Exception xcptn)
{
Debug.WriteLine("Save Exception: " + xcptn.Message);
return(xcptn.Message);
}
return("success");
}
