public IHttpActionResult SetSimulationUsers(int id, [FromBody] SimulationUserModel[] simulationUsers)
{
UserInformationModel userInformation = ESECSecurity.GetUserInformation(Request);
SimulationUserUpdateMethods[userInformation.Role](id, simulationUsers.ToList(), userInformation);
return(Ok(simulationUsers));
}
private void DisposeData(CommunicateObj obj)
{
if (UIModel != null)
{
}
else
{
//如果是登录信息的话
if (obj.DataType == CommunicateObj.DataTypeEnum.Login)
{
LoginModel liModel = obj.GetDataObj <LoginModel>();
UserInformationModel uiModel = UISQLControler.UnityIns.GetUserFromUserName(liModel.UserName);
//如果查找不到用户名
//密码错误
if ((uiModel == null) || (uiModel.Password != liModel.Password))
{
CommunicateObj objBack = new CommunicateObj(CommunicateObj.DataTypeEnum.LoginInBack, null, false, "用户名不存在");
this.SendMessage(objBack);
}
else
{
UIModel = uiModel;
CommunicateObj objBack = new CommunicateObj(CommunicateObj.DataTypeEnum.LoginInBack, uiModel, true, typeof(UserInformationModel));
this.SendMessage(objBack);
}
}
}
}
private void Login()
{
UserValidationModel model = new UserValidationModel();
model.LoginName = textBoxName.Text.TrimStart().TrimEnd();
model.Password = textBoxPassWord.Text;
if (String.IsNullOrEmpty(model.LoginName) || String.IsNullOrEmpty(model.Password))
{
labelMessage.Text = "请录入登录信息";
}
else
{
HandlingResult result = new HandlingResult();
ValidationAction action = new ValidationAction();
result = action.ValidateLogin(model);
if (result.Successed)
{
UserInformationModel user = (UserInformationModel)result.Result;
UserInformationContext.ID = user.Id;
UserInformationContext.Name = user.Name;
UserInformationContext.LoginName = user.LoginName;
UserInformationContext.LoginTime = DateTime.Now;
UserInformationContext.LoginPass = true;
UserInformationContext.StoreId = "";
Close();
}
else
{
labelMessage.Text = result.Message;
}
}
}
public MarketplaceItem CreateItemListing(UserInformationModel<User> aCreatingUser, ItemViewModel anItemViewModel)
{
if (!ValidItem(anItemViewModel)) {
return null;
}
string myImageName = string.Empty;
if (anItemViewModel.Image != null) {
try {
myImageName = AWSPhotoHelper.TakeImageAndResizeAndUpload(anItemViewModel.Image,
AWSHelper.GetClient(),
SiteConfiguration.MarketplacePhotosBucket(),
anItemViewModel.Title.GetHashCode().ToString(),
MarketplaceConstants.ITEM_MAX_SIZE);
} catch (Exception myException) {
throw new PhotoException("Unable to upload the image.", myException);
}
}
MarketplaceItem myItem = theMarketplaceRepository.AddItemToMarketplace(
anItemViewModel.UniversityId,
aCreatingUser.Details,
anItemViewModel.ItemType,
anItemViewModel.Title,
anItemViewModel.Description,
double.Parse(anItemViewModel.Price),
myImageName,
TimeZoneInfo.ConvertTimeToUtc(DateTime.Parse(anItemViewModel.ExpireListing)));
return myItem;
}
//Changes forgotten password
public async Task ForgotPasswordAsync(UserModel user, ForgotPasswordModel forgotPassword)
{
if (user.Status == (int)UserStatus.NotValid)
{
CustomException errors = new CustomException((int)HttpStatusCode.BadRequest);
errors.AddError("None Verified Email", "Your email is not verified");
errors.Throw();
}
if (user.Status == (int)UserStatus.Banned)
{
CustomException errors = new CustomException((int)HttpStatusCode.BadRequest);
errors.AddError("User Is Banned", "User is banned from application");
errors.Throw();
}
InformationModel ForgotPasswordVerificationCodeInfo = await _informationRepository.GetInformationByInformationNameAsync("ForgotPasswordVerificationCode");
InformationModel ForgotPasswordVerificationCodeGenerateDateInfo = await _informationRepository.GetInformationByInformationNameAsync("ForgotPasswordVerificationCodeGenerateDate");
UserInformationModel ForgotPasswordVerificationCode = await _userInformationRepository.GetUserInformationByIdAsync(user.Id, ForgotPasswordVerificationCodeInfo.Id);
UserInformationModel ForgotPasswordVerificationCodeGenerateDate = await _userInformationRepository.GetUserInformationByIdAsync(user.Id, ForgotPasswordVerificationCodeGenerateDateInfo.Id);
//Bad request
if (ForgotPasswordVerificationCode == null)
{
CustomException errors = new CustomException((int)HttpStatusCode.BadRequest);
errors.AddError("Email Verification Code Not Exist", "There is no verification code which is generated for you");
errors.Throw();
}
//Generated code timed out
if (String.Format("{0:u}", DateTime.UtcNow.AddMinutes(-15)).CompareTo(ForgotPasswordVerificationCodeGenerateDate.Value) > 0)
{
_userInformationRepository.Delete(ForgotPasswordVerificationCode);
_userInformationRepository.Delete(ForgotPasswordVerificationCodeGenerateDate);
CustomException errors = new CustomException((int)HttpStatusCode.BadRequest);
errors.AddError("Verification Code Timeout", "Verification code timed out, please request another verification code");
errors.Throw();
}
//Verification code accepted
if (ForgotPasswordVerificationCode.Value == forgotPassword.VerificationCode)
{
user.Password = forgotPassword.NewPassword;
_userRepository.Update(user);
_userInformationRepository.Delete(ForgotPasswordVerificationCode);
_userInformationRepository.Delete(ForgotPasswordVerificationCodeGenerateDate);
}
//Verification code does not matched
else
{
CustomException errors = new CustomException((int)HttpStatusCode.BadRequest);
errors.AddError("Verification Code", "Verification code does not matched");
errors.Throw();
}
}
public static bool IsAllowedToDelete(UserInformationModel<User> aCurrentUser, Board aBoardMessage)
{
return aCurrentUser !=null
&& (aCurrentUser.Details.Id == aBoardMessage.OwnerUserId
|| aCurrentUser.Details.Id == aBoardMessage.PostedUserId
|| PermissionHelper<User>.AllowedToPerformAction(aCurrentUser, SocialPermission.Delete_Any_Board_Message));
}
public IEnumerable<UserStatus> GetLatestUserStatusesWithinUniversity(UserInformationModel<User> aUser,string aUniversityId, int aLimit)
{
return theUserStatusRepository
.GetLatestUserStatuses(aUniversityId)
.Where(s => FriendHelper.IsFriend(aUser.Details, s.User) || s.Everyone)
.Take(aLimit); ;
}
public SearchResultsModel GetAllSearchResults(UserInformationModel<User> aUserInformation, string aSearchString, int aPage)
{
IEnumerable<TextBook> myTextBooks = new List<TextBook>();
IEnumerable<MarketplaceItem> myItems = new List<MarketplaceItem>();
string myUniversityId = "All";
if (aUserInformation != null) {
myUniversityId = UniversityHelper.GetMainUniversity(aUserInformation.Details).Id;
myTextBooks = theSearchRepository.GetTextBookByTitle(myUniversityId, aSearchString);
myItems = theMarketplaceSerivce.GetLatestItemsSellingInUniversityByTitle(myUniversityId, aSearchString);
} else {
myTextBooks = theSearchRepository.GetTextBookByTitle(aSearchString);
myItems = theMarketplaceSerivce.GetLatestItemsSellingByTitleForAllUniversitiesAndTypes(aSearchString);
}
List<ISearchResult> mySearchResult = new List<ISearchResult>();
mySearchResult.AddRange(myTextBooks.Select(r => new TextBookSearchResult(r) {
UserInformationModel = aUserInformation
}));
mySearchResult.AddRange(myItems.Select(r => new ItemSearchResult(r) {
UserInformationModel = aUserInformation
}));
mySearchResult = mySearchResult.OrderByDescending(i => i.GetDateTime()).ToList();
int myTotalResults = myItems.Count<MarketplaceItem>() + myTextBooks.Count<TextBook>();
SearchResultsModel myModel =
BuildSearchResultsModel(myUniversityId, mySearchResult, SearchFilter.ALL, aPage,
aSearchString, myTotalResults, SearchByForAll(),
SearchBy.None, OrderByForAll(), OrderBy.None);
return myModel;
}
public IHttpActionResult DeleteSimulation(int id)
{
UserInformationModel userInformation = ESECSecurity.GetUserInformation(Request);
SimulationDeletionMethods[userInformation.Role](id, userInformation);
return(Ok());
}
private void LoadFormWithData()
{
if (_userInformationList == null || _userInformationList.Count <= 0)
{
_isAddNewMode = true;
return;
}
_userInformation = _userInformationList[_currentIndex];
txtUserId.Text = Convert.ToString(_userInformation.Id);
cbxUserType.SelectedValue = _userInformation.UserTypeId;
cbxEmployee.SelectedValue = _userInformation.EmployeeId;
cbxRole.SelectedValue = _userInformation.RoleId;
txtUsername.Text = _userInformation.Username;
//txtPassword.Text = _userInformation.Password;
txtPasswordAge.Text = Convert.ToString(_userInformation.PasswordAgeLimit);
if (_userInformation.LastPasswordChangedDate != null)
{
txtLastPasswordChangedDate.Text = Convert.ToDateTime(_userInformation.LastPasswordChangedDate).ToString("dd-MMM-yyyy");
}
if (_userInformation.LastLockedDate != null)
{
txtLastLockedDate.Text = Convert.ToDateTime(_userInformation.LastLockedDate).ToString("dd-MMM-yyyy");
}
txtWrongPasswordTryLimit.Text = Convert.ToString(_userInformation.WrongPasswordTryLimit);
chkIsPasswordChanged.Checked = _userInformation.IsPasswordChanged;
chkIsLocked.Checked = _userInformation.IsLocked;
chkIsSuperAdmin.Checked = _userInformation.IsSuperAdmin;
chkIsActive.Checked = _userInformation.IsActive;
dgvUserList.Rows[_currentIndex].Selected = true;
dgvUserList.CurrentCell = dgvUserList.Rows[_currentIndex].Cells[0];
_isChanged = false;
_isAddNewMode = false;
}
public IHttpActionResult UpdateSimulation([FromBody] SimulationModel model)
{
UserInformationModel userInformation = ESECSecurity.GetUserInformation(Request);
SimulationUpdateMethods[userInformation.Role](model, userInformation);
return(Ok());
}
private BaseFilterModel GetFilterForUserEnglishLevel(
int neededCount,
UserInformationModel userInformation,
PerEnglishLevelTaskInformationModel userLevelInfo)
{
var totalCountOfUserLevelTasks = userLevelInfo.GrammarPartCount.Values.Sum();
if (totalCountOfUserLevelTasks < neededCount)
{
return(null);
}
var countWithUsersGrammarParts = 0;
foreach (var grammarPart in userInformation.FavouriteGrammarParts)
{
if (userLevelInfo.GrammarPartCount.TryGetValue(grammarPart, out int grammarPartCount))
{
countWithUsersGrammarParts += grammarPartCount;
}
}
if (countWithUsersGrammarParts >= neededCount)
{
return(BaseFilterModel.CreateFromUserInformation(userInformation));
}
var filterWithAllGrammarPartsForLevel = new BaseFilterModel();
filterWithAllGrammarPartsForLevel.EnglishLevel = new[] { userInformation.EnglishLevel };
filterWithAllGrammarPartsForLevel.GrammarPart = userLevelInfo.GrammarPartCount.Keys.ToList();
return(filterWithAllGrammarPartsForLevel);
}
public ClassDetailsModel GetClass(UserInformationModel<User> aViewingUser, int aClassId, ClassViewType aClassViewType)
{
Class myClass = theClassRepository.GetClass(aClassId);
return new ClassDetailsModel() {
Class = myClass
};
}
/// <summary>
/// Creates a default UserCriteriaModel for a new user, based on their role.
/// Administrators have full access by default.
/// All other users have no access by default.
/// </summary>
/// <param name="userInformation">UserInformationModel</param>
/// <returns>UserCriteriaModel</returns>
private UserCriteriaModel GenerateDefaultUserCriteria(UserInformationModel userInformation) =>
new UserCriteriaModel
{
Username = userInformation.Name,
Criteria = null,
HasCriteria = false,
HasAccess = userInformation.Role == Role.ADMINISTRATOR
};
public IEnumerable<AuthorityViewableZipCode> GetAuthorityViewableZipCodes(UserInformationModel<User> anAdminUser, string anEmail)
{
if (!PermissionHelper<User>.AllowedToPerformAction(anAdminUser, SocialPermission.Create_Authority_Verification_Token)) {
throw new PermissionDenied(ErrorKeys.PERMISSION_DENIED);
}
return theAuthenticationRepo.GetAuthorityViewableZipCodes(anEmail);
}
protected void ButtonRegister_Click(object sender, EventArgs e)
{
var userStore = new UserStore <IdentityUser>();
userStore.Context.Database.Connection.ConnectionString =
System.Configuration.ConfigurationManager.ConnectionStrings["db_1525657_sweethswixthshopConnectionString"].ConnectionString;
var manager = new UserManager <IdentityUser>(userStore);
var user = new IdentityUser {
UserName = TextBoxUsername.Text
};
if (TextBoxPassword.Text == TextBoxConfirmPassword.Text)
{
try
{
IdentityResult result = manager.Create(user, TextBoxPassword.Text);
if (result.Succeeded)
{
UserInformation info = new UserInformation
{
Address = TextAddress.Text,
Surname = TextSurname.Text,
Forename = TextForename.Text,
GUID = user.Id
};
UserInformationModel model = new UserInformationModel();
model.InserUserInformation(info);
var authenticationManager = HttpContext.Current.GetOwinContext().Authentication;
var userIdentity = manager.CreateIdentity(user, DefaultAuthenticationTypes.ApplicationCookie);
authenticationManager.SignIn(new AuthenticationProperties(), userIdentity);
Response.Redirect("~/Default.aspx");
}
else
{
LiteralStatus.Text = result.Errors.FirstOrDefault();
}
}
catch (Exception ex)
{
LiteralStatus.Text = ex.ToString();
}
}
else
{
LiteralStatus.Text = "Confirm Password dont match with your password!";
}
}
public void DeleteUserStatus(UserInformationModel<User> aUserInfo, int aStatusId)
{
UserStatus myUserStatus = theUserStatusRepository.GetUserStatus(aStatusId);
if (aUserInfo.UserId == myUserStatus.UserId) {
theUserStatusRepository.DeleteUserStatus(aStatusId);
} else {
throw new PermissionDenied(ErrorKeys.PERMISSION_DENIED);
}
}
//
// GET: /User/Details/5
public ActionResult Details(int id = 0)
{
User userSelect = db.Users.Find(id);
Group groupSelect = db.Groups.Find(userSelect.GroupId);
var selectRole = "";
switch (userSelect.Role)
{
case 0:
selectRole = "Студент";
break;
case 1:
selectRole = "Преподаватель";
break;
case 2:
selectRole = "Администратор";
break;
}
UserInformationModel userInfo = new UserInformationModel
{
Id = userSelect.Id,
Email = userSelect.Email,
LastName = userSelect.LastName,
FirstName = userSelect.FirstName,
Date = userSelect.Date,
DateCreate = userSelect.DateCreate,
Active = userSelect.Active,
Phone = userSelect.Phone,
Role = selectRole,
RoleId = userSelect.Role
};
if (groupSelect == null)
{
userInfo.Group = "Группа не задана";
}
else
{
userInfo.Group = groupSelect.Name;
}
if (User.Identity.IsAuthenticated)
{
var userName = User.Identity.Name;
var user = userService.GetByName(userName);
ViewBag.User = user;
ViewBag.Messages = messageService.GetRecepientNotReadCount(user.Id);
ViewBag.Groups = db.Groups.ToList();
}
if (userSelect == null)
{
return(HttpNotFound());
}
return(View(userInfo));
}
public void UpdateFeatureSettings(UserInformationModel<User> aUser, UpdateFeaturesModel anUpdateFeaturesModel)
{
IEnumerable<Feature> myEnabledFeatures = (from f in anUpdateFeaturesModel.Features
where f.Second
select f.First);
IEnumerable<Feature> myDisabledFeatures = (from f in anUpdateFeaturesModel.Features
where !f.Second
select f.First);
theFeatureRepo.UpdateFeatureSettings(aUser.Details, myEnabledFeatures, myDisabledFeatures);
}
public bool ApproveGroupMember(UserInformationModel<User> aUser, int aGroupMemberId, string aTitle, bool anAdministrator)
{
if (!ValidTitle(aTitle)) {
return false;
}
theGroupRepository.ApproveGroupMember(aUser.Details, aGroupMemberId, aTitle, anAdministrator);
return true;
}
public bool ActivateGroup(UserInformationModel<User> aUser, int aGroupId)
{
if (!ValidateAdmin(aUser, aGroupId)) {
return false;
}
theGroupRepository.ActivateGroup(aUser.Details, aGroupId);
return true;
}
public RedirectToRouteResult Entry()
{
UserInformationModel userInformation = TempData["UserInformation"] as UserInformationModel;
TempData.Remove("UserInformation");
if (Session["UserInformation"] == null)
{
return(RedirectToAction("Login", "User"));
}
return(RedirectToAction("Home", "Admin", userInformation));
}
public static BaseFilterModel CreateFromUserInformation(UserInformationModel userInformation)
{
var englishLevels = new[] { userInformation.EnglishLevel };
var filterModel = new BaseFilterModel()
{
GrammarPart = userInformation.FavouriteGrammarParts,
EnglishLevel = englishLevels,
};
return(filterModel);
}
public UserProfileModel AuthorityProfile(UserInformationModel<User> anAuthorityUserInformation)
{
User myAuthorityUser = anAuthorityUserInformation.Details;
IEnumerable<Issue> myPeoplesIssues = new List<Issue>();
IEnumerable<IssueReply> myPeoplesIssueReplies = new List<IssueReply>();
string myAuthorityPosition = myAuthorityUser.UserPosition.Position.ToUpper();
if (AuthorityClassification.GetAuthorityPostionsViewableByZip().Contains(myAuthorityPosition)) {
myPeoplesIssues = theRepository.AuthorityIssuesFeedByZipCode(myAuthorityUser);
myPeoplesIssueReplies = theRepository.AuthorityIssueReplysFeedByZipCode(myAuthorityUser);
} else if (AuthorityClassification.GetAuthorityPostionsViewableByCityState().Contains(myAuthorityPosition)) {
myPeoplesIssues = theRepository.AuthorityIssuesFeedByCityState(myAuthorityUser);
myPeoplesIssueReplies = theRepository.AuthorityIssueReplysFeedByCityState(myAuthorityUser);
} else if (AuthorityClassification.GetAuthorityPostionsViewableByState().Contains(myAuthorityPosition)) {
myPeoplesIssues = theRepository.AuthorityIssuesFeedByState(myAuthorityUser);
myPeoplesIssueReplies = theRepository.AuthorityIssueReplysFeedByState(myAuthorityUser);
}
List<IssueFeedModel> myIssueFeed = CreateIssueFeedForAuthority(myPeoplesIssues, anAuthorityUserInformation, PersonFilter.People).ToList<IssueFeedModel>();
List<IssueReplyFeedModel> myIssueReplyFeed = CreateIssueReplyFeedForAuthority(myPeoplesIssueReplies, anAuthorityUserInformation, PersonFilter.People).ToList<IssueReplyFeedModel>();
IEnumerable<IssueFeedModel> myPoliticiansIssueFeed = CreateIssueFeed(theRepository.IssueFeedByRole(UserRoleHelper.PoliticianRoles()), myAuthorityUser, PersonFilter.Politicians);
IEnumerable<IssueReplyFeedModel> myPoliticiansIssueReplyFeed = CreateIssueReplyFeed(theRepository.IssueReplyFeedByRole(UserRoleHelper.PoliticianRoles()), myAuthorityUser, PersonFilter.Politicians);
IEnumerable<IssueFeedModel> myPoliticalCandidateIssueFeed = CreateIssueFeed(theRepository.IssueFeedByRole(UserRoleHelper.PoliticalCandidateRoles()), myAuthorityUser, PersonFilter.PoliticalCandidates);
IEnumerable<IssueReplyFeedModel> myPoliticalCandidateIssueReplyFeed = CreateIssueReplyFeed(theRepository.IssueReplyFeedByRole(UserRoleHelper.PoliticalCandidateRoles()), myAuthorityUser, PersonFilter.PoliticalCandidates);
//myIssueFeed.AddRange(myPoliticiansIssueFeed);
//myIssueFeed.AddRange(myPoliticalCandidateIssueFeed);
myIssueFeed = myIssueFeed.OrderByDescending(i => i.DateTimeStamp).Take<IssueFeedModel>(10).ToList<IssueFeedModel>();
//myIssueReplyFeed.AddRange(myPoliticiansIssueReplyFeed);
//myIssueReplyFeed.AddRange(myPoliticalCandidateIssueReplyFeed);
myIssueReplyFeed = myIssueReplyFeed.OrderByDescending(ir => ir.DateTimeStamp).Take<IssueReplyFeedModel>(10).ToList<IssueReplyFeedModel>();
Issue myRandomLocalIssue = theRepository.RandomLocalIssue(myAuthorityUser);
UserProfileModel myModel = new UserProfileModel(myAuthorityUser) {
IssueFeed = myIssueFeed,
IssueReplyFeed = myIssueReplyFeed,
};
Random myRandom = new Random();
if (myRandom.Next() % 2 == 1) {
if (!SetForLocalIssue(myModel, myAuthorityUser)) {
SetForFriendSuggestion(myModel, anAuthorityUserInformation);
}
} else {
if (!SetForFriendSuggestion(myModel, anAuthorityUserInformation)) {
SetForLocalIssue(myModel, myAuthorityUser);
}
}
return myModel;
}
public UserInformationForm()
{
InitializeComponent();
IKernel kernel = BootStrapper.Initialize();
_userInformationService = kernel.GetService(typeof(UserInformationService)) as UserInformationService;
_userTypeService = kernel.GetService(typeof(UserTypeService)) as UserTypeService;
_employeeInformationService = kernel.GetService(typeof(EmployeeInformationService)) as EmployeeInformationService;
_roleService = kernel.GetService(typeof(RoleService)) as RoleService;
_userInformation = new UserInformationModel();
}
public bool CreateUserStatus(UserInformationModel<User> aUserInfo, string aStatus, bool anEveryone)
{
if (!ValidStatus(aStatus)) {
return false;
}
University myUniversity = UniversityHelper.GetMainUniversity(aUserInfo.Details);
theUserStatusRepository.CreateUserStatus(aUserInfo.Details, myUniversity, aStatus, anEveryone);
return true;
}
public WorkspaceViewModel(IScreen screen, UserInformationModel userInformation)
{
HostScreen = screen;
UserInformation = userInformation;
Logout = ReactiveCommand.Create(() => { HostScreen.Router.NavigateAndReset.Execute(new LoginViewModel(HostScreen)); });
Router.Navigate.Execute(new EmployeesViewModel(this));
this.WhenActivated((CompositeDisposable disposables) =>
{
});
}
public UniversityView GetUniversityProfile(UserInformationModel<User> aUserInformation, string aUniversityId)
{
University myUniversity = theUniversityRepository.GetUniversity(aUniversityId);
IEnumerable<TextBook> myTextBooks = theTextBookService.GetTextBooksForUniversity(aUniversityId);
IEnumerable<MarketplaceItem> myMarketplaceItems = theMarketplaceService.GetAllLatestItemsSellingInUniversity(aUniversityId);
return new UniversityView() {
University = myUniversity,
TextBooks = myTextBooks,
MarketplaceItems = myMarketplaceItems
};
}
public ActionResult Reset()
{
HttpCookie cookie = HttpContext.Request.Cookies.Get("Email");
if (cookie != null)
{
UserInformationModel userInformationModel = new UserInformationModel();
userInformationModel.email = cookie.Value;
return(View(userInformationModel));
}
return(RedirectToAction("Login", "User"));
}
public IHttpActionResult SaveCriteriaDrivenBudgets(int id, [FromBody] List <CriteriaDrivenBudgetModel> models)
{
UserInformationModel userInformation = ESECSecurity.GetUserInformation(Request);
var result = CriteriaDrivenBudgetsSaveMethods[userInformation.Role](id, models, userInformation);
if (result.IsCompleted)
{
return(Ok());
}
return(NotFound());
}
public IHttpActionResult SaveCommittedProjectsFiles()
{
if (!Request.Content.IsMimeMultipartContent())
{
throw new ConstraintException("The data provided is not a valid MIME type.");
}
UserInformationModel userInformation = ESECSecurity.GetUserInformation(Request);
repo.SaveCommittedProjectsFiles(HttpContext.Current.Request, db, userInformation);
return(Ok());
}
//Admin request to user for inviting home
public async Task InviteHomeRequestAsync(UserModel user, string invitedUsername)
{
Task <InformationModel> firstNameInfo = _informationRepository.GetInformationByInformationNameAsync("FirstName");
Task <InformationModel> lastNameInfo = _informationRepository.GetInformationByInformationNameAsync("LastName");
if (user.Position != (int)UserPosition.Admin)
{
CustomException errors = new CustomException((int)HttpStatusCode.BadRequest);
errors.AddError("Authorisation Constraint", "You are not authorized for this request, you must be administrator of home");
errors.Throw();
}
var home = (await _userRepository.GetByIdAsync(user.Id, true)).Home;
//Admin waiting for user's accept
UserModel invitedUser = await _userRepository.GetByUsernameAsync(invitedUsername);
if (invitedUser == null)
{
CustomException errors = new CustomException((int)HttpStatusCode.BadRequest);
errors.AddError("User Not Exist", "User is not exist");
errors.Throw();
}
if (invitedUser.Position != (int)UserPosition.HasNotHome)
{
CustomException errors = new CustomException((int)HttpStatusCode.BadRequest);
errors.AddError("User Has Home", "You can not invite a user who already has home");
errors.Throw();
}
UserInformationModel firstName = await _userInformationRepository.GetUserInformationByIdAsync(user.Id, (await firstNameInfo).Id);
UserInformationModel lastName = await _userInformationRepository.GetUserInformationByIdAsync(user.Id, (await lastNameInfo).Id);
FCMModel fcm = new FCMModel(invitedUser.DeviceId, new Dictionary <string, object>());
fcm.notification.Add("title", "Eve Katılma Daveti");
fcm.notification.Add("body", String.Format("{0} {1}({2}) evine katılmanız için davet ediyor.", firstName.Value, lastName.Value, user.Username));
await _fcmService.SendFCMAsync(fcm);
fcm = new FCMModel(invitedUser.DeviceId, type: "InviteHomeRequest");
fcm.data.Add("InvitedHomeId", home.Id);
fcm.data.Add("InviterUsername", user.Username);
fcm.data.Add("InviterFirstName", firstName.Value);
fcm.data.Add("InviterLastName", lastName.Value);
await _fcmService.SendFCMAsync(fcm);
}
public Class CreateClass(UserInformationModel<User> aCreatedByUser, CreateClassModel aCreateClassModel)
{
if (!ValidClass(aCreateClassModel)) {
return null;
}
Class myClass= theClassRepository.CreateClass(aCreatedByUser.Details, aCreateClassModel.UniversityId,
aCreateClassModel.ClassSubject.Trim().ToUpper(),
aCreateClassModel.ClassCourse.Trim().ToUpper(),
aCreateClassModel.ClassTitle.Trim());
return myClass;
}
public double CalculateBMI(UserInformationModel userInformationModel)
{
double result = 0.0;
if (userInformationModel.Weight == 0 || userInformationModel.Height == 0)
{
return(0);
}
result = userInformationModel.Weight / (userInformationModel.Height * userInformationModel.Height / 100 / 100);
return(result);
}
private bool CheckPassword(UserInformationModel oUser, string inputPassword)
{
//string hashedPass = GetHashPassword(oUser.User.NomorInduk, inputPassword, oUser.User.Salt);
if (oUser.User.UserPassword.Equals(inputPassword))
{
return(true);
}
else
{
return(false);
}
}
public UserInformationVM()
{
Command = new UserInformationCommand(this);
try
{
UserInformationM = new UserInformationModel();
Users = new ObservableCollection <User>(UserInformationM.GetUsers());
}
catch (Exception e)
{
(App.Current as App).navigation.MainWindows.comments.Text = e.Message.ToString();
}
}
public ActionResult Index(UserInformationModel model)
{
CountCalories calories = new CountCalories();
var result = calories.Calculate(model);
//var bmi = Math.Round(calories.CalculateBMI(data.UserInformationModelRepo), 1);
//var userBmiInfo = calories.interpreteBMI(bmi);
//data.UserBmiModel.Bmi = bmi;
//data.UserBmiModel.UserBmiInfo = userBmiInfo;
//return View(data.UserBmiModel);
ViewBag.Message = "Your contact page." + result;
return(View());
}
public AccountModel GetSignInUser(string userName, string password)
{
AccountModel oResult = new AccountModel();
try
{
UserInformationModel oUserInfo = GetValidateUser(userName);
}
catch (Exception ex)
{
oResult.Exception = oException.Set(ex);
}
return(oResult);
}
public bool CreateIssue(UserInformationModel<User> aUserCreating, Issue aIssueToCreate)
{
if (!ValidateIssue(aIssueToCreate) || !IssueDoesntExist(aIssueToCreate.Title)) {
return false;
}
if (!AllowedToPerformAction(aUserCreating, SocialPermission.Post_Issue)) {
return false;
}
Issue myIssue = theIssueRepository.CreateIssue(aIssueToCreate, aUserCreating.Details);
theIssueRepository.MarkIssueAsUnreadForAuthor(myIssue.Id);
return true;
}
public JsonResult ChangePassword(UserInformationModel userInformation)
{
if (userInformation.Id <= 0)
{
userInformation.Id = LoginInformation.UserInformation.Id;
}
userInformation.SetUpdateProperties(LoginInformation.UserInformation.Id);
_userInformationService.ChangePassword(userInformation);
return(new JsonResult {
Data = userInformation
});
}
/// <summary>
/// Gets the UserCriteria of the specified user.
/// If a user does not have any criteria,
/// a default setting will be created for them based on their role.
/// </summary>
/// <param name="db">BridgeCareContext</param>
/// <param name="userInformation">UserInformationModel</param>
/// <returns>UserCriteriaModel</returns>
public UserCriteriaModel GetOwnUserCriteria(BridgeCareContext db, UserInformationModel userInformation)
{
if (!db.UserCriteria.Any(criteria => criteria.USERNAME == userInformation.Name))
{
log.Info($"User '{userInformation.Name}' has logged in for the first time.");
var newUserCriteria = new UserCriteriaEntity(GenerateDefaultUserCriteria(userInformation));
db.UserCriteria.Add(newUserCriteria);
db.SaveChanges();
return(new UserCriteriaModel(newUserCriteria));
}
var userCriteria = db.UserCriteria.Single(criteria => criteria.USERNAME == userInformation.Name);
return(new UserCriteriaModel(userCriteria));
}
public static PersonalInformation ToUserInformation(this UserInformationModel model)
{
return(new PersonalInformation()
{
Id = model.Id,
BirthDay = model.BirthDay,
BloodStyle = model.BloodStyle,
Favorates = model.Favorates,
From = model.From,
LiveIn = model.LiveIn,
PersonnalDescription = model.PersonnalDescription,
UserId = model.UserId,
User = model.UserRelated
});
}
protected void Register_Click(object sender, EventArgs e)
{
var userStore = new UserStore <IdentityUser>();
userStore.Context.Database.Connection.ConnectionString = "data source=PC-ITSIX61;initial catalog=Garage;integrated security=True;";
var manager = new UserManager <IdentityUser>(userStore);
var user = new IdentityUser();
user.UserName = UserNameTB.Text;
if (PasswordTB.Text.Equals(ConfirmPasswordTB.Text))
{
try
{
var result = manager.Create(user, PasswordTB.Text);
if (result.Succeeded)
{
var userInfo = new UserInformation();
userInfo.FirstName = FirstName.Text;
userInfo.LastName = LastName.Text;
userInfo.Address = Address.Text;
userInfo.GUID = user.Id;
userInfo.PostalCode = Convert.ToInt32(PostalCode.Text);
var userModel = new UserInformationModel();
userModel.InsertUserInformation(userInfo);
var autenticationManager = HttpContext.Current.GetOwinContext().Authentication;
var userIdentity = manager.CreateIdentity(user, DefaultAuthenticationTypes.ApplicationCookie);
autenticationManager.SignIn(new AuthenticationProperties(), userIdentity);
Response.Redirect("~/Index.aspx");
}
else
{
Status.Text = result.Errors.FirstOrDefault();
}
}
catch (Exception ex)
{
Status.Text = ex.ToString();
}
}
else
{
Status.Text = "Password and Confirm password must match";
}
}
public async Task <IHttpActionResult> RunSimulation([FromBody] SimulationModel model)
{
UserInformationModel userInformation = ESECSecurity.GetUserInformation(Request);
var result = await Task.Factory.StartNew(() => SimulationRunMethods[userInformation.Role](model, userInformation));
if (result.IsCompleted)
{
repo.SetSimulationLastRunDate(model.simulationId, db);
}
else
{
return(InternalServerError(new Exception(result.Result)));
}
return(Ok());
}
public JsonResult Save([Bind(Include = "Id, UserTypeId, EmployeeId, RoleId, Username, Password, PasswordAgeLimit, IsPasswordChanged, IsLocked, WrongPasswordTryLimit, IsSuperAdmin, IsActive")] UserInformationModel userInformation, bool isInsert)
{
if (isInsert)
{
userInformation.SetCreateProperties(LoginInformation.UserInformation.Id);
userInformation.Id = _userInformationService.Insert(userInformation);
}
else
{
userInformation.SetUpdateProperties(LoginInformation.UserInformation.Id);
_userInformationService.Update(userInformation);
}
return(new JsonResult {
Data = _userInformationService.GetById(userInformation.Id)
});
}
public bool AddZipCodesForUser(UserInformationModel<User> anAdminUser, string anEmail, string aZipCodes)
{
if (!PermissionHelper<User>.AllowedToPerformAction(anAdminUser, SocialPermission.Create_Authority_Verification_Token)) {
throw new PermissionDenied(ErrorKeys.PERMISSION_DENIED);
}
if (!IsValidZipCodes(anEmail, aZipCodes)) {
return false;
}
IEnumerable<int> myZipCodes = aZipCodes.Split(',').Select(z => int.Parse(z.Trim()));
theAuthenticationRepo.AddZipCodesForUser(anAdminUser.Details, anEmail, myZipCodes);
return true;
}
public bool CreateTextBook(UserInformationModel<User> aCreatingUser, TextBookViewModel aCreateTextBookModel)
{
if (!ValidTextBook(aCreateTextBookModel)) {
return false;
}
Class myClass = theClassRepo.GetClass(aCreateTextBookModel.UniversityId, aCreateTextBookModel.ClassSubject, aCreateTextBookModel.ClassCourse);
if(myClass == null) {
theClassRepo.CreateClass(aCreatingUser.Details, aCreateTextBookModel.UniversityId, aCreateTextBookModel.ClassSubject, aCreateTextBookModel.ClassCourse, "No title");
}
string myBookImageName = string.Empty;
if (aCreateTextBookModel.BookImage != null) {
try {
myBookImageName = AWSPhotoHelper.TakeImageAndResizeAndUpload(aCreateTextBookModel.BookImage,
AWSHelper.GetClient(),
SiteConfiguration.TextbookPhotosBucket(),
aCreateTextBookModel.BookTitle.GetHashCode().ToString(),
TextBookConstants.BOOK_MAX_SIZE);
} catch (Exception myException) {
throw new PhotoException("Unable to upload the textbook image.", myException);
}
}
theTextBookRepo.CreateTextbook(aCreatingUser.Details,
aCreateTextBookModel.UniversityId,
aCreateTextBookModel.TextBookCondition,
aCreateTextBookModel.BookTitle,
aCreateTextBookModel.BookAuthor,
myBookImageName,
aCreateTextBookModel.ClassSubject,
aCreateTextBookModel.ClassCourse,
aCreateTextBookModel.Edition == null ? 0 : int.Parse(aCreateTextBookModel.Edition),
double.Parse(aCreateTextBookModel.Price),
string.IsNullOrEmpty(aCreateTextBookModel.Details) ? null : aCreateTextBookModel.Details,
aCreateTextBookModel.ISBN);
return true;
}
public IEnumerable<Pair<Feature, bool>> GetFeatureSettingsForUser(UserInformationModel<User> aUser)
{
IEnumerable<Feature> myAllFeatures = theFeatureRepo.GetAllFeatures().OrderBy(f => f.ListOrder);
IEnumerable<FeaturesEnabled> myAllFeaturesEnabled = theFeatureRepo.GetFeaturesEnabledForUser(aUser.Details);
List<Pair<Feature, bool>> myFeatureAndSelection = new List<Pair<Feature, bool>>();
foreach (Feature myFeature in myAllFeatures) {
bool myEnabled = (from fe in myAllFeaturesEnabled
where fe.FeatureName.Equals(myFeature.Name)
select fe.Enabled)
.DefaultIfEmpty(true)
.FirstOrDefault();
myFeatureAndSelection.Add(new Pair<Feature, bool>() {
First = myFeature,
Second = myEnabled
});
}
return myFeatureAndSelection;
}
public static bool IsAllowed(User aPrivacyUser, PrivacyAction aPrivacyAction, UserInformationModel<User> aViewingUser)
{
bool myIsAllowed = true;
IEnumerable<string> myTargetUsersSettings =
(from p in aPrivacyUser.UserPrivacySettings.ToList<UserPrivacySetting>()
select p.PrivacySettingName).ToList<string>();
IEnumerable<Friend> myTargetUserFriends = aPrivacyUser.Friends.ToList<Friend>();
if (aPrivacyAction == PrivacyAction.DisplayProfile) {
if (aViewingUser == null || (aViewingUser != null && !FriendHelper.IsFriend(aPrivacyUser, aViewingUser.Details))) {
if (HasPrivacySetting(myTargetUsersSettings, SocialPrivacySetting.Display_Profile_To_Everyone)) {
myIsAllowed = true;
} else {
myIsAllowed = false;
}
}
}
return myIsAllowed;
}
public void MarkItemAsSeen(UserInformationModel<User> aUserInfo, int anItemId)
{
theSendItemsRepo.MarkItemAsSeen(aUserInfo.Details, anItemId);
}
private static bool ShouldDisplayEditLink(UserInformationModel<User> aUserInformation, Issue anIssue)
{
return (PermissionHelper<User>.AllowedToPerformAction(aUserInformation, SocialPermission.Edit_Issue) && aUserInformation.Details.Id == anIssue.UserId)
|| PermissionHelper<User>.AllowedToPerformAction(aUserInformation, SocialPermission.Edit_Any_Issue);
}
public SearchResultsModel GetClassSearchResults(UserInformationModel<User> aUserInformation, string aSearchString,
int aPage, SearchBy aSearchBy, OrderBy anOrderBy, string aUniversityId)
{
IEnumerable<Class> myClasses = new List<Class>();
string myUniversityId = "All";
if (!aUniversityId.Equals("All")) {
myUniversityId = aUniversityId;
if (aSearchBy == SearchBy.Title) {
myClasses = theSearchRepository.GetClassByTitle(myUniversityId, aSearchString);
} else if (aSearchBy == SearchBy.ClassCode) {
myClasses = theSearchRepository.GetClassByClassCode(myUniversityId, aSearchString);
}
} else {
if (aSearchBy == SearchBy.Title) {
myClasses = theSearchRepository.GetClassByTitle(aSearchString);
} else if (aSearchBy == SearchBy.ClassCode) {
myClasses = theSearchRepository.GetClassByClassCode(aSearchString);
}
}
if (anOrderBy == OrderBy.Title) {
myClasses = myClasses.OrderBy(r => r.Title);
} else if (anOrderBy == OrderBy.ClassCode) {
myClasses = myClasses.OrderBy(r => r.Subject + r.Course);
}
List<ISearchResult> mySearchResult = new List<ISearchResult>();
mySearchResult.AddRange(myClasses.Select(r => new ClassSearchResult(r)));
int myTotalResults = myClasses.Count<Class>();
SearchResultsModel myModel =
BuildSearchResultsModel(myUniversityId, mySearchResult, SearchFilter.CLASS, aPage, aSearchString,
myTotalResults, SearchByForClass(), aSearchBy,
OrderByForClass(), anOrderBy);
return myModel;
}
public SearchResultsModel GetTextBookSearchResults(UserInformationModel<User> aUserInformation, string aSearchString,
int aPage, SearchBy aSearchBy, OrderBy anOrderBy, string aUniversityId)
{
IEnumerable<TextBook> myTextBooks = new List<TextBook>();
string myUniversityId = "All";
if (!aUniversityId.Equals("All")) {
myUniversityId = aUniversityId;
if (aSearchBy == SearchBy.Title) {
myTextBooks = theSearchRepository.GetTextBookByTitle(myUniversityId, aSearchString);
} else if (aSearchBy == SearchBy.ClassCode) {
myTextBooks = theSearchRepository.GetTextBookByClassCode(myUniversityId, aSearchString);
}
} else {
if (aSearchBy == SearchBy.Title) {
myTextBooks = theSearchRepository.GetTextBookByTitle(aSearchString);
} else if (aSearchBy == SearchBy.ClassCode) {
myTextBooks = theSearchRepository.GetTextBookByClassCode(aSearchString);
}
}
if (anOrderBy == OrderBy.Title) {
myTextBooks = myTextBooks.OrderBy(r => r.BookTitle);
} else if (anOrderBy == OrderBy.ClassCode) {
myTextBooks = myTextBooks.OrderBy(r => r.ClassSubject + r.ClassCourse);
} else if (anOrderBy == OrderBy.LowestPrice) {
myTextBooks = myTextBooks.OrderBy(r => r.Price);
} else if (anOrderBy == OrderBy.HighestPrice) {
myTextBooks = myTextBooks.OrderByDescending(r => r.Price);
}
List<ISearchResult> mySearchResult = new List<ISearchResult>();
mySearchResult.AddRange(myTextBooks.Select(r => new TextBookSearchResult(r) {
UserInformationModel = aUserInformation
}));
int myTotalResults = myTextBooks.Count<TextBook>();
SearchResultsModel myModel =
BuildSearchResultsModel(myUniversityId, mySearchResult, SearchFilter.TEXTBOOK, aPage,
aSearchString, myTotalResults, SearchByForTextbook(),
aSearchBy, OrderByForTextbook(), anOrderBy);
return myModel;
}
public SearchResultsModel GetUserSearchResults(UserInformationModel<User> aUserInformation, string aSearchString,
int aPage, SearchBy aSearchBy, OrderBy anOrderBy, string aUniversityId)
{
IEnumerable<User> myUsers = new List<User>();
if (aSearchBy == SearchBy.Name) {
if (aUserInformation == null) {
myUsers = theSearchRepository.GetUserByName(aSearchString);
} else {
myUsers = theSearchRepository.GetUserByName(aUserInformation.UserId, aSearchString);
}
}
if (anOrderBy == OrderBy.Name) {
myUsers = myUsers.OrderBy(r => r.FirstName + " " + r.LastName);
}
List<ISearchResult> mySearchResult = new List<ISearchResult>();
mySearchResult.AddRange(myUsers.Select(r => new UserSearchResult(r) {
UserInformationModel = aUserInformation
}));
int myTotalResults = myUsers.Count<User>();
SearchResultsModel myModel =
BuildSearchResultsModel("All", mySearchResult, SearchFilter.USER, aPage,
aSearchString, myTotalResults, SearchByForPeople(),
aSearchBy, OrderByForPeople(), anOrderBy);
return myModel;
}
public SearchResultsModel MarketplaceSearchResults(UserInformationModel<User> aUserInformation, string aSearchString, int aPage, SearchBy aSearchBy, OrderBy anOrderBy, string anItemType, string aUniversityId)
{
IEnumerable<MarketplaceItem> myItems = new List<MarketplaceItem>();
string myUniversityId = "All";
if (!aUniversityId.Equals("All")) {
myUniversityId = aUniversityId;
if (aSearchBy == SearchBy.Title) {
myItems = theMarketplaceSerivce.GetLatestItemsSellingInUniversityByItemAndTitle(myUniversityId, anItemType, aSearchString);
}
} else {
if (aSearchBy == SearchBy.Title) {
myItems = theMarketplaceSerivce.GetLatestItemsSellingByTypeAndTitleForAnyUniversity(anItemType, aSearchString);
}
}
if (anOrderBy == OrderBy.Title) {
myItems = myItems.OrderBy(r => r.Title);
} else if (anOrderBy == OrderBy.LowestPrice) {
myItems = myItems.OrderBy(r => r.Price);
} else if (anOrderBy == OrderBy.HighestPrice) {
myItems = myItems.OrderByDescending(r => r.Price);
} else if (anOrderBy == OrderBy.Newest) {
myItems = myItems.OrderBy(r => r.DateTimeStamp);
}
List<ISearchResult> mySearchResult = new List<ISearchResult>();
mySearchResult.AddRange(myItems.Select(r => new ItemSearchResult(r) {
UserInformationModel = aUserInformation
}));
int myTotalResults = myItems.Count();
SearchResultsModel myModel =
BuildSearchResultsModel(myUniversityId, mySearchResult, (SearchFilter)Enum.Parse(typeof(SearchFilter), anItemType), aPage,
aSearchString, myTotalResults, SearchByForItems(),
aSearchBy, OrderByForItems(), anOrderBy);
return myModel;
}
public void UpdateUserRegionSpecifics(UserInformationModel<User> aUserInfo, IEnumerable<Pair<AuthorityPosition, int>> aToAddAndUpdate, IEnumerable<Pair<AuthorityPosition, int>> aToRemove)
{
theAuthenticationRepo.UpdateUserRegionSpecifics(aUserInfo.Details, aToAddAndUpdate, aToRemove);
}
private static string IssueInformationDiv(Issue anIssue, bool anAnonymous, UserInformationModel<User> aUserInfoModel, bool aHasStance, string anIssueInfoCssClass, string anEditAndStanceCssClass, string aReportCssClass, string anAgreeCssClass,
string aDisagreeCssClass, string anDeleteCssClass, string anEditCssClass, SiteSection aSiteSection, int aSourceId)
{
var myIssueInfoDiv = new TagBuilder("div");
myIssueInfoDiv.AddCssClass(anIssueInfoCssClass);
var myIssueInfoPadding = new TagBuilder("div");
myIssueInfoPadding.AddCssClass("p-a10");
myIssueInfoPadding.InnerHtml += SharedStyleHelper.InfoSpeakSpan("speak-lft");
var myHeadTitle = new TagBuilder("h1");
var myIssueLink = new TagBuilder("a");
myIssueLink.MergeAttribute("href", LinkHelper.IssueUrl(anIssue.Title));
myIssueLink.InnerHtml = anIssue.Title;
myHeadTitle.InnerHtml += myIssueLink.ToString();
string myName = NameHelper.FullName(anIssue.User);
string myProfileLink = LinkHelper.Profile(anIssue.User);
if (anAnonymous) {
myName = HAVConstants.ANONYMOUS;
myProfileLink = "#";
}
var myNameLink = new TagBuilder("a");
myNameLink.AddCssClass("name-2");
myNameLink.MergeAttribute("href", myProfileLink);
myNameLink.InnerHtml = myName;
var myLocationSpan = new TagBuilder("span");
myLocationSpan.AddCssClass("loc c-white");
myLocationSpan.InnerHtml = anIssue.City + ", " + anIssue.State;
string myUserType = GetUserTypeForIssue(anIssue);
var myIconSpan = new TagBuilder("span");
myIconSpan.AddCssClass(myUserType);
myIconSpan.MergeAttribute("title", myUserType);
myIconSpan.InnerHtml = " ";
myIssueInfoPadding.InnerHtml += myHeadTitle.ToString();
myIssueInfoPadding.InnerHtml += myNameLink.ToString();
myIssueInfoPadding.InnerHtml += " ";
myIssueInfoPadding.InnerHtml += myLocationSpan.ToString();
myIssueInfoPadding.InnerHtml += " ";
myIssueInfoPadding.InnerHtml += myIconSpan.ToString();
myIssueInfoPadding.InnerHtml += new TagBuilder("br").ToString();
myIssueInfoPadding.InnerHtml += PresentationHelper.ReplaceCarriageReturnWithBR(anIssue.Description);
myIssueInfoPadding.InnerHtml += SharedStyleHelper.ClearDiv();
var myEditAndStanceDiv = new TagBuilder("div");
myEditAndStanceDiv.AddCssClass(anEditAndStanceCssClass);
myEditAndStanceDiv.InnerHtml += SharedStyleHelper.StyledHtmlDiv(aReportCssClass, ComplaintHelper.IssueLink(anIssue.Id)).ToString();
myEditAndStanceDiv.InnerHtml += DeleteDiv(aUserInfoModel, anIssue, anDeleteCssClass);
myEditAndStanceDiv.InnerHtml += EditDiv(aUserInfoModel, anIssue, anEditCssClass);
if (anAgreeCssClass != string.Empty) {
myEditAndStanceDiv.InnerHtml += AgreeDiv(aUserInfoModel, anIssue, anAgreeCssClass, aSiteSection, aSourceId);
}
if (aDisagreeCssClass != string.Empty) {
myEditAndStanceDiv.InnerHtml += DisagreeDiv(aUserInfoModel, anIssue, aDisagreeCssClass, aSiteSection, aSourceId);
}
myEditAndStanceDiv.InnerHtml += SharedStyleHelper.ClearDiv();
myIssueInfoPadding.InnerHtml += myEditAndStanceDiv.ToString();
myIssueInfoDiv.InnerHtml += myIssueInfoPadding.ToString();
return myIssueInfoDiv.ToString();
}
private ActionResult RemoveMember(UserInformationModel<User> aUserInfo, int aGroupId, int aUserRemovingId, string aMessage)
{
try {
bool myResult = theGroupService.RemoveGroupMember(aUserInfo, aUserRemovingId, aGroupId);
if (myResult) {
TempData["Message"] += MessageHelper.SuccessMessage(aMessage);
}
} catch (Exception myException) {
LogError(myException, REMOVE_ERROR);
TempData["Message"] += MessageHelper.ErrorMessage(REMOVE_ERROR);
}
return RedirectToAction("Details", "Group", new { id = aGroupId });
}
public bool RequestTokenForAuthority(UserInformationModel<User> aRequestingUser, string anEmail, string anExtraInfo, string anAuthorityType, string anAuthorityPosition)
{
if (!PermissionHelper<User>.AllowedToPerformAction(aRequestingUser, SocialPermission.Create_Authority_Verification_Token)) {
throw new CustomException(HAVConstants.NOT_ALLOWED);
}
if(!IsValidAuthorityInformation(anEmail, anAuthorityType, anAuthorityPosition)) {
return false;
}
Random myRandom = new Random(DateTime.UtcNow.Millisecond);
string myToken = myRandom.Next().ToString();
string myHashedToken = HashHelper.DoHash(myToken);
bool myExists = theAuthenticationRepo.TokenForEmailExists(anEmail, anAuthorityType, anAuthorityPosition);
if (myExists) {
theAuthenticationRepo.UpdateTokenForEmail(anEmail, myHashedToken, anAuthorityType, anAuthorityPosition);
} else {
theAuthenticationRepo.CreateTokenForEmail(aRequestingUser.Details, anEmail, myHashedToken, anAuthorityType, anAuthorityPosition);
}
SendTokenEmail(anEmail, anExtraInfo, myToken, anAuthorityType, anAuthorityPosition);
return true;
}
private static bool GetHasStance(Issue anIssue, UserInformationModel<User> aUserInfoModel)
{
bool myHasDisposition = aUserInfoModel != null &&
(from s in anIssue.IssueDispositions
where s.UserId == aUserInfoModel.Details.Id
select s).Count<IssueDisposition>() > 0 ? true : false;
return myHasDisposition;
}
