public override async Task Handle()
{
if (Request.Headers["Authorization"] != null)
{
Guid token = Guid.Parse(Request.Headers["Authorization"]);
CurrentUser = manager.AuthorizeUser(token);
}
string requestJson;
using (var textReader = new StreamReader(Request.InputStream, Request.ContentEncoding))
{
requestJson = await textReader.ReadToEndAsync().ConfigureAwait(false);
}
TRequestData requestData = JsonConvert.DeserializeObject <TRequestData>(requestJson);
TResponseData responseData = await Handle(requestData).ConfigureAwait(false);
var responseJson = JsonConvert.SerializeObject(responseData);
Response.StatusCode = 200;
Response.Headers.Add(HttpResponseHeader.ContentType, "application/json");
byte[] buffer = Encoding.UTF8.GetBytes(responseJson);
Response.ContentLength64 = buffer.Length;
Response.OutputStream.Write(buffer, 0, buffer.Length);
}
public override void OnActionExecuting(HttpActionContext actionContext)
{
if (actionContext.ActionDescriptor.GetCustomAttributes <AllowAnonymousAttribute>().Any())
{
base.OnActionExecuting(actionContext);
}
else
{
var user = AuthorizedUser.Current.User;
if (user == null)
{
//未验证（登录）的用户, 而且是非匿名访问，则转向登录页面
//HttpContext.Current.Response.Redirect("~/Account/Login", true);
actionContext.Response =
actionContext.Request.CreateErrorResponse(HttpStatusCode.Unauthorized, new HttpError("用户未登录"));
AuthorizedUser.LoginOut();
return;
}
else
{
//没有配置权限策略
base.OnActionExecuting(actionContext);
}
}
}
public void Setup()
{
token = new JwtSecurityToken();
generateTokensServiceMock = new Mock <IGenerateSecurityTokens>();
generateTokensServiceMock
.Setup(a => a.GenerateSecurityToken(
It.IsAny <Claim[]>(),
It.IsAny <JwtSettings>(),
It.IsAny <DateTime>()))
.Returns(() => token);
generateTokensServiceMock
.Setup(a => a.WriteToken(It.IsAny <JwtSecurityToken>()))
.Returns(() => writtenToken);
settings = new WebApiSettings()
{
JwtSettings = new JwtSettings()
};
_service = new TokenResponseService(
generateTokensServiceMock.Object,
Mock.Of <ILogger <TokenResponseService> >(),
settings);
user = new AuthorizedUser(new User())
{
Name = "Name",
Role = "Role"
};
}
public async Task <ActionResult> DeleteUser(string userId)
{
string currentUserId = User.Identity.GetUserId();
string returnUrl = Request.UrlReferrer.AbsolutePath + Request.UrlReferrer.Query;
AuthorizedUser user = await UserManager.FindByIdAsync(userId);
AuthorizedUser curUser = await UserManager.FindByIdAsync(currentUserId);
bool isCurUserAdmin = curUser.IsAdmin;
var userLogins = await UserManager.GetLoginsAsync(userId);
// Check if current user is not admin
// user has no rights to delete users
// or if current user tries to delete himself
if (!isCurUserAdmin || userId == currentUserId)
{
return(RedirectToAction("Index", "Home"));
}
foreach (var login in userLogins)
{
if (RemoveLogins(userId, login.LoginProvider, login.ProviderKey))
{
return(Redirect(returnUrl));
}
}
helper.DeleteUser(userId);
return(Redirect(returnUrl));
}
public async Task <IHttpActionResult> Suggestion([FromBody] AuthorizedUser authorizedUser)
{
this.authenticateUser(authorizedUser);
UserAccount retrievedUser = await authorizedUser.getUserAccount(db).ConfigureAwait(false);
await retrievedUser.Login().ConfigureAwait(false);
TilerUser tilerUser = retrievedUser.getTilerUser();
tilerUser.updateTimeZoneTimeSpan(authorizedUser.getTimeSpan);
if (retrievedUser.Status)
{
DateTimeOffset nowTime = authorizedUser.getRefNow();
if (retrievedUser.ScheduleLogControl.Now == null)
{
var retrievalOption = DataRetrievalSet.analysisManipulation;
DB_Schedule schedule = new DB_Schedule(retrievedUser, nowTime, authorizedUser.getCurrentLocation(), retrievalOptions: retrievalOption);
retrievedUser.ScheduleLogControl.Now = schedule.Now;
}
await SuggestionAnalysis(retrievedUser.ScheduleLogControl, authorizedUser.getCurrentLocation()).ConfigureAwait(false);
}
var retValue = new PostBackData("", 0);
return(Ok(retValue.getPostBack));
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new AuthorizedUser {
UserName = model.Email, Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
//associate
_policyService.AssociateExistingDevices(user.Id);
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return(RedirectToAction("Index", "Home"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
/// <summary>
/// Get all the videos by specific user
/// </summary>
/// <param name="userId">User's id</param>
/// <returns>Collection of videos by specific user</returns>
public IEnumerable <Video> GetVideos(string userId)
{
AuthorizedUser user = GetUsers(userId);
var videos = GetVideos().Where(s => s.Author == user).ToList();
return(videos.OrderByDescending(s => s.PublishDate).ToList());
}
private void Notification()
{
IdentityMessage toSend = new IdentityMessage();
while (true)
{
Thread.Sleep(300000);
DateTime now = DateTime.Now;
DateTime start = now.AddMinutes(25);
DateTime end = now.AddMinutes(30);
List <Order> Orders = db.Orders.Where(x => x.CompletionDateTime >= start && x.CompletionDateTime <= end).ToList();
foreach (var order in Orders)
{
foreach (var join in order.Joinings)
{
if (join.User.GetType().BaseType.Name == typeof(AuthorizedUser).Name)
{
AuthorizedUser user = (AuthorizedUser)join.User;
toSend.Destination = user.AppUser.Email;
toSend.Body = textOfNotification;
toSend.Subject = subjectOfNotification;
eServise.Send(toSend);
}
}
}
}
}
/// <summary>
/// Creates a card for the authorized user using AddCard behavior call. Then sets the authorized user's card number in LMS.
/// </summary>
/// <param name="strategy"></param>
/// <param name="authorizedUser"></param>
/// <returns></returns>
public BaseResult AddCard(ClientStrategy strategy, AuthorizedUser authorizedUser)
{
var result = new BaseResult();
var lmsPerson = new LmsPerson()
{
AuthorizedUser = authorizedUser
};
string cardNumber = string.Empty;
var addCardResult = strategy.AddCard(lmsPerson, out cardNumber);
result.AppendResult(addCardResult);
if (addCardResult.Result)
{
//Store the CCM AccountNumber received from the response to the authorized user CardNumber field
var authUser = _app.AuthorizedUsers.SingleOrDefault(a => a.AuthorizedUserId == authorizedUser.AuthorizedUserId);
authUser.CardNumber = cardNumber;
}
else
{
result.AddMessage(MessageType.Warning, $"An error occured creating the plastic card. The card will not be created on CCM for {authorizedUser.FirstName} {authorizedUser.LastName}.");
result.Result = true;
}
return(result);
}
public async Task <ActionResult> ChangePhoto(string userId, HttpPostedFileBase upload)
{
string returnUrl = Request.UrlReferrer.AbsolutePath + Request.UrlReferrer.Query;
if (ModelState.IsValid)
{
string imagePath;
if (upload != null)
{
string filePath = "/Files/ProfileImages/" + userId + ".jpg";
imagePath = filePath;
AuthorizedUser user = await UserManager.FindByIdAsync(userId);
string oldPhotoPath = Server.MapPath(user.ProfileImagePath);
if (user.ProfileImagePath.Contains("ProfileImages") && System.IO.File.Exists(oldPhotoPath))
{
System.IO.File.Delete(oldPhotoPath);
}
else
{
helper.ChangeProfileImage(imagePath, userId);
}
upload.SaveAs(Server.MapPath("~" + filePath));
}
else
{
return(Redirect(returnUrl));
}
return(RedirectToAction("UserPage", "User", new { userId }));
}
return(Redirect(returnUrl));
}
public async Task <Account> GetAccountDetails(AuthorizedUser user)
{
var request = _sheetsService.Spreadsheets.Values.Get(_gSheetsSpreadsheetId, "VAid!A2:AC");
var response = await request.ExecuteAsync();
var data = response.Values
.Where(row => row.Count() == 29)
.Select(RowAsUserAndAccount);
if (!data.TryFirst(x => x.AuthorizedUser.Equals(user), out var authorizedAccount))
{
return(null);
}
var account = authorizedAccount.Account;
account.Metadata = await GetAdditionalMetadata();
account.PotentialTransactions = await GetPotentialTransactions(data.Select(x => x.Account), account);
account.AcceptableRecipients = GetAcceptableRecipients(data.Select(x => x.Account), account);
account.RecentTransactions = await GetRecentTransactions(account);
// Cross reference to not suggest potential transactions that are also recent (active) transactions
account.PotentialTransactions = account.PotentialTransactions
.Where(potential => !account.RecentTransactions.Any(t => t.Status == TransactionStatus.Approved && t.OtherRuler == potential.RulerName))
.ToList();
return(account);
}
public AuthorizedUser CreateUser(string userName,
string email,
EDeviceClaimsContext context,
string role = ApplicationRoles.PolicyHolder,
string firstName = "",
string lastName = "")
{
var userStore = new UserStore <AuthorizedUser>(context);
var userManager = new UserManager <AuthorizedUser>(userStore);
var user = userManager.FindByEmail(email);
if (user != null)
{
return(user);
}
user = new AuthorizedUser {
UserName = userName, Email = email, FirstName = firstName, LastName = lastName
};
userManager.Create(user, "password");
userManager.AddToRole(user.Id, role);
//roleManager.Create(new IdentityRole { Name = "admin" });
//userManager.AddToRole(user.Id, "admin");
return(user);
}
public Phone GetMainPhone(AuthorizedUser authorizedUser)
{
Phone mainPhone = null;
var phoneMobile = authorizedUser.Phones.FirstOrDefault(
p => p.PhoneTypeId == _lmsRepository.GetLookupIdByTypeAndCode(LookupTypes.PhoneType, LookupCodes.PhoneType.Mobile)
);
var phoneHome = authorizedUser.Phones.FirstOrDefault(
p => p.PhoneTypeId == _lmsRepository.GetLookupIdByTypeAndCode(LookupTypes.PhoneType, LookupCodes.PhoneType.Home)
);
if (phoneMobile != null)
{
mainPhone = phoneMobile;
}
else if (phoneHome != null && phoneMobile == null)
{
mainPhone = phoneHome;
}
else
{
mainPhone = authorizedUser.Phones.FirstOrDefault();
}
return(mainPhone);
}
public string Authenticate(string username, string password)
{
var refreshToken = GenerateRefreshToken();
var authorizedUser = new AuthorizedUser {
Email = username, RefreshToken = refreshToken
};
_database.AuthorizedUsers.Add(authorizedUser);
_database.Save();
int userId;
var accessToken = GetAccessToken(authorizedUser.Id, username, password, out userId);
var response = new
{
Id = userId,
access_token = accessToken,
refresh_token = refreshToken
};
return(JsonConvert.SerializeObject(response, new JsonSerializerSettings()
{
Formatting = Formatting.Indented
}));
}
private void выходИзАккаунтаToolStripMenuItem1_Click(object sender, EventArgs e)
{
if (currentUser == null)
{
return;
}
usersBox.Items.Remove(currentUser.login);
usersBox.SelectedText = "";
currentUser.imapClient.DisconnectFromServer();
authorizedUsers.Remove(currentUser);
listView1.Items.Clear();
listView2.Items.Clear();
listView3.Items.Clear();
ClearInputs();
webBrowser1.DocumentText = "";
SubjectLabel.Text = "";
label1.Text = "";
label2.Text = "";
label3.Text = "";
usersBox.Text = "";
currentUser = null;
mailFolderInfo = null;
}
public async Task <IActionResult> Signup(SignupViewModel model)
{
if (ModelState.IsValid)
{
Gender?gender = model.Gender != String.Empty ? (Gender?)Enum.Parse(typeof(Gender), model.Gender) : null;
User user = new AuthorizedUser()
{
UserName = model.Email, FirstName = model.FirstName, LastName = model.LastName, Email = model.Email,
EmailConfirmed = true, Blocked = false,
RoleId = 3, Gender = gender, Age = model.Age,
Height = model.Height, Weight = model.Weight, PhoneNumber = model.Phone
};
var result = await _userManager.CreateAsync(user, model.Password);
var add_role = await _userManager.AddToRoleAsync(user, "AuthorizedUser");
User signinUser = await _userManager.FindByEmailAsync(model.Email);
if (result.Succeeded)
{
await _signInManager.SignInAsync(signinUser, false);
return(RedirectToAction("Index", "Home"));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
}
return(View(model));
}
private AuthorizedUser CreateUser(string userName, string email, string firstName, string lastName, EDeviceClaimsContext context, string role = AppRoles.PolicyHolder)
{
var userStore = new UserStore <AuthorizedUser>(context);
var userManager = new UserManager <AuthorizedUser>(userStore);
var roleStore = new RoleStore <IdentityRole>(context);
var roleManager = new RoleManager <IdentityRole>(roleStore);
var user = userManager.FindByEmail(email);
if (user != null)
{
return(user);
}
user = new AuthorizedUser
{
UserName = userName,
Email = email,
FirstName = firstName,
LastName = lastName
};
userManager.Create(user, "password");
roleManager.Create(new IdentityRole {
Name = role
});
userManager.AddToRole(user.Id, role);
return(user);
}
/// <summary>
/// Класс с ответственностью возвращать обновления пользователя.
/// Хранит так же всякую дичь для связи с сервером ВК.
/// </summary>
///
/// <param name="user">
/// Пользователь, который прошел процедуру залогинивания и
/// получил ключ-токен для совершения действий с API.
/// </param>
public VKUpdatesGetter(AuthorizedUser user)
{
connector.Authorize(new ApiAuthParams()
{
AccessToken = user.AccessToken
});
UpdateLongpollServerInfo();
}
public Address GetCurrentAddress(AuthorizedUser authorizedUser)
{
var currentAddress = authorizedUser.Addresses.FirstOrDefault(
a => a.AddressTypeId == _lmsRepository.GetLookupIdByTypeAndCode(LookupTypes.AddressType, LookupCodes.AddressType.Current)
);
return(currentAddress);
}
public async Task <IList <DistributionReadModel> > Filter([FromBody] DistributionsFilter filter)
{
AuthorizedUser user = authorizedUserProvider.Get();
return(await mediator.Send(new GetDistributionsByFilter.Query {
Filter = filter, IsAdmin = user.IsAdmin, UserSid = user.Sid
}));
}
public void UpdatePolicyUserId(AuthorizedUser user, ICollection <Policy> devices)
{
foreach (var device in devices)
{
device.UserId = user.Id;
Repo.Update(device);
}
}
public ActionResult RemoveUser(int id)
{
AuthorizedUser authorizedUser = _db.AuthorizedUsers.Find(id);
_db.AuthorizedUsers.Remove(authorizedUser);
_db.SaveChanges();
return(RedirectToAction("Index"));
}
/// <inheritdoc />
public override async Task OnConnectedAsync()
{
await base.OnConnectedAsync();
AuthorizedUser currentUser = authorizedUserProvider.Get();
await Groups.AddToGroupAsync(Context.ConnectionId, GetGroupName(currentUser));
logger.LogInformation($"{currentUser} connected to notifications.");
}
public async Task PublishJobEventsForProcessingJobs(int limit)
{
AuthorizedUser user = authorizedUserProvider.Get();
foreach ((string jobId, string eventType) in jobStorageService.GetAllActiveJobsForUser(user.Sid, limit))
{
await PublishToCurrentUser(new JobSignalREvent(eventType, new JobEventPayload(jobId, 0), user.Sid));
}
}
/// <inheritdoc />
public override async Task OnDisconnectedAsync(Exception exception)
{
await base.OnDisconnectedAsync(exception);
AuthorizedUser currentUser = authorizedUserProvider.Get();
await Groups.RemoveFromGroupAsync(Context.ConnectionId, GetGroupName(currentUser));
logger.LogInformation($"{currentUser} disconnected from notifications.");
}
/// <inheritdoc />
public AuthorizedUser Get()
{
if (!httpContext.User.Identity.IsAuthenticated)
{
return(AuthorizedUser.Anonymous);
}
return(AuthorizedUser.CreateFromClaimPrincipal(httpContext.User));
}
public IActionResult UsersAdd([FromForm] AuthorizedUser user)
{
if (user.Id != 0 && user.Name != null)
{
_usersCollection.Insert(user.Id, user);
}
return(RedirectToAction("UsersList"));
}
public Claim[] GetClaims(AuthorizedUser user)
{
var claims = new[]
{
new Claim(ClaimTypes.Name, user.Name),
new Claim(ClaimTypes.Role, user.Role)
};
return(claims);
}
public ActionResult UserDetail(int id)
{
AuthorizedUser user = db.AllUsers.OfType <AuthorizedUser>().FirstOrDefault(x => x.Id == id);
if (user == null)
{
return(HttpNotFound());
}
return(PartialView(user));
}
private IActionResult AuthTokenResponse(AuthorizedUser user)
{
var response = _responseService.PrepareTokenResponse(user);
return(Ok(new
{
token = response.Token,
validTo = response.ValidTo,
user
}));
}
