private static bool RetriveSessionFromCookie()
{
var cookies = WebGlobalVariable.Request.Cookies;
HttpCookie cookie = cookies[RightConst.USER_INFO_COOKIE_NAME];
if (cookie == null)
return false;
CookieUserInfo userInfo = CookieUserInfo.FromEncodeString(cookie.Value);
if (userInfo == null)
return false;
EmptyDbDataSource source = new EmptyDbDataSource();
using (source)
using (UserResolver resolver = new UserResolver(source))
{
try
{
IUserInfo info = resolver.CheckUserLogOnById(userInfo.UserId, userInfo.Password);
WebGlobalVariable.SessionGbl.AppRight.Initialize(info);
return true;
}
catch
{
return false;
}
}
}
public ProjectsController(ILogger <ProjectsController> logger, DtoGenerator dtoGenerator, UserResolver userResolver, Uploads uploads)
{
_logger = logger;
_dtoGenerator = dtoGenerator;
_userResolver = userResolver;
_uploads = uploads;
}
public AccountController(
UserResolver <TUser> userResolver,
UserManager <TUser> userManager,
SignInManager <TUser> signInManager,
IIdentityServerInteractionService interaction,
IClientStore clientStore,
IAuthenticationSchemeProvider schemeProvider,
IEventService events,
IEmailSender emailSender,
IGenericControllerLocalizer <AccountController <TUser, TKey> > localizer,
LoginConfiguration loginConfiguration,
RegisterConfiguration registerConfiguration)
{
_userResolver = userResolver;
_userManager = userManager;
_signInManager = signInManager;
_interaction = interaction;
_clientStore = clientStore;
_schemeProvider = schemeProvider;
_events = events;
_emailSender = emailSender;
_localizer = localizer;
_loginConfiguration = loginConfiguration;
_registerConfiguration = registerConfiguration;
}
private static async Task Main(string[] args)
{
Console.WriteLine("Hello World from WebApiClient!");
Console.WriteLine("Creating Token now...");
const string mySecret = "DO NOT TELL ANYONE";
IUserResolver userResolver = new UserResolver(); // todo: DependencyInjection in .NET Core Console App ? (add AutoFac ?)
byte[] secret = Encoding.ASCII.GetBytes(mySecret);
TimeSpan expirationTime = TimeSpan.FromHours(7.0);
JwtUserService userService = new JwtUserService(userResolver, secret, expirationTime);
string username = @"myDomain\myUser";
string password = "******";
string audience = "Job Center";
string issuer = "Linux Client";
User user = await userService.AuthenticateAsync(username, password, audience, issuer);
Console.WriteLine("... Token generated.");
Console.WriteLine("Accessing WebApi (and adding Token to Header) now...");
var test = new MyRestClient();
await test.GetDataAsync(user.Tokens.AuthToken);
Console.WriteLine("Done!");
Console.ReadKey();
}
public LoginController(ILogger <LoginController> logger, IOptions <ForgeConfiguration> optionsAccessor, UserResolver userResolver, IOptions <InviteOnlyModeConfiguration> inviteOnlyModeOptionsAccessor)
{
_logger = logger;
_userResolver = userResolver;
Configuration = optionsAccessor.Value.Validate();
_inviteOnlyModeConfig = inviteOnlyModeOptionsAccessor.Value;
}
/// <inheritdoc />
protected override async Task <bool> CheckName(SubCategoryViewModel model, CancellationToken cancellationToken)
{
if (model.CategoryId <= 0)
{
return(false);
}
var query = DbContext.SubCategories
.AsNoTracking()
.Where(c => !c.IsDeleted)
.Where(c => c.CategoryId == model.CategoryId)
.Where(c => c.Name == model.Name)
.Where(c => c.User.UserId == UserResolver.GetUserId());
if (model.Id <= 0)
{
return(!await query.AnyAsync(cancellationToken));
}
else
{
return(!await query
.Where(c => c.Id != model.Id)
.AnyAsync(cancellationToken));
}
}
public async Task InvokeAsync(HttpContext context, UserResolver resolver)
{
while (context.Request.Headers.TryGetValue(HeaderNames.Authorization, out var values))
{
var headerValue = values[0];
if (headerValue.Length <= BearerPrefix.Length)
{
break;
}
if (!headerValue.StartsWith(BearerPrefix))
{
break;
}
string token = headerValue.Substring(BearerPrefix.Length);
if (string.IsNullOrEmpty(token))
{
break;
}
resolver.Token = token;
break;
}
// Call the next delegate/middleware in the pipeline
await _next(context);
}
public async Task<IActionResult> Post([FromBody] UserResolver model)
{
if (string.IsNullOrEmpty(model.Email))
NotifierError("email empty.");
var response = new object();
// Recupera o usuário
var userApplication = await user.GetByEmail(model.Email);
// Verifica se o usuário existe
if (userApplication == null)
NotifierError("user not found or without permission.");
else
{
// Gera o Token
model.Email = userApplication.Email.EmailAddress;
var token = GenerateToken.GetToken(model);
response = new
{
email = model.Email,
name = userApplication.Name.FullName,
token = token
};
}
return CustomResponse(response);
}
public AdoptJobItem(ILogger logger, ProjectInfo projectInfo, string fileName, ProjectWork projectWork, DtoGenerator dtoGenerator, UserResolver userResolver)
: base(logger, null, projectWork)
{
_projectInfo = projectInfo;
_fileName = fileName;
_dtoGenerator = dtoGenerator;
_userResolver = userResolver;
}
public MigrationJob(MigrationBucketKeyProvider bucketProvider, UserResolver userResolver, ProjectWork projectWork, ILogger <MigrationJob> logger, ProjectService projectService)
{
_bucketProvider = bucketProvider;
_userResolver = userResolver;
_projectWork = projectWork;
_logger = logger;
_projectService = projectService;
}
public ProjectWork(ILogger <ProjectWork> logger, Arranger arranger, FdaClient fdaClient,
DtoGenerator dtoGenerator, UserResolver userResolver)
{
_logger = logger;
_arranger = arranger;
_fdaClient = fdaClient;
_dtoGenerator = dtoGenerator;
_userResolver = userResolver;
}
private async Task<bool> CheckAccountType(int accountType, CancellationToken cancellationToken)
{
return await DbContext.AccountTypes
.Where(c => !c.IsDeleted)
.AsNoTracking()
.Where(c => c.User.UserId == UserResolver.GetUserId())
.Where(c => c.Id == accountType)
.AnyAsync(cancellationToken);
}
private async Task <bool> CheckCategory(int categoryId, CancellationToken cancellationToken)
{
return(await DbContext.Categories
.AsNoTracking()
.Where(c => !c.IsDeleted)
.Where(c => c.Id == categoryId)
.Where(c => c.User.UserId == UserResolver.GetUserId())
.AnyAsync(cancellationToken));
}
public ProjectsController(ILogger <ProjectsController> logger, DtoGenerator dtoGenerator, UserResolver userResolver, ProfileProvider profileProvider, Uploads uploads, ProjectService projectService)
{
_logger = logger;
_dtoGenerator = dtoGenerator;
_userResolver = userResolver;
_profileProvider = profileProvider;
_uploads = uploads;
_projectService = projectService;
}
public OutputData Update(IInputData input, object instance)
{
BasePasswordData passwd = instance.Convert<BasePasswordData>();
using (EmptyDbDataSource source = new EmptyDbDataSource())
using (UserResolver resolver = new UserResolver(source))
{
return ChangePasswd(resolver, passwd);
}
}
public async Task <ActionResult> GetSveInstance()
{
try
{
return(Ok(await _kursInstancaService.Get(UserResolver.GetUserRoles(HttpContext.User), UserResolver.GetUposlenikId(HttpContext.User))));
}
catch (Exception ex)
{
return(BadRequest(new ApiException(ex.Message, System.Net.HttpStatusCode.BadRequest)));
}
}
public JobsHub(ILogger <JobsHub> logger, ProjectWork projectWork, LinkGenerator linkGenerator, UserResolver userResolver, Uploads uploads, DtoGenerator dtoGenerator)
{
_logger = logger;
_projectWork = projectWork;
_linkGenerator = linkGenerator;
_userResolver = userResolver;
_uploads = uploads;
_dtoGenerator = dtoGenerator;
_sender = new Sender(this);
}
public async Task <ActionResult> GetKlijentData()
{
try
{
return(Ok(await _klijentDataService.GetKlijentData(UserResolver.GetKlijentId(HttpContext.User))));
}
catch (Exception ex)
{
return(BadRequest(new ApiException(ex.Message, System.Net.HttpStatusCode.BadRequest)));
}
}
public DataMigrationController(ILogger <DataMigrationController> logger, IOptions <DefaultProjectsConfiguration> optionsAccessor,
ProjectWork projectWork, UserResolver userResolver, IForgeOSS forgeOSS, LocalCache localCache)
{
_logger = logger;
_userResolver = userResolver;
_bucket = _userResolver.AnonymousBucket;
_projectWork = projectWork;
_defaultProjectsConfiguration = optionsAccessor.Value;
_forgeOSS = forgeOSS;
_localCache = localCache;
}
public async Task <ActionResult> Get([FromQuery] KlijentSearchRequestModel model = null)
{
try
{
return(Ok(await _userService.GetKlijenti(UserResolver.GetUposlenikId(HttpContext.User), UserResolver.GetUserRoles(HttpContext.User), model)));
}
catch (Exception ex)
{
return(BadRequest(new ApiException(ex.Message, System.Net.HttpStatusCode.BadRequest)));
}
}
public async Task <ActionResult> PrijaviSeZaKurs([FromBody] int instancaId)
{
try
{
return(Ok(await _kursInstancaDataService.PrijaviSeZaKurs(instancaId, UserResolver.GetKlijentId(HttpContext.User))));
}
catch (Exception ex)
{
return(BadRequest(new ApiException(ex.Message, System.Net.HttpStatusCode.BadRequest)));
}
}
public async Task <ActionResult> GetMojeInstance([FromQuery] MojaKursInstancaFilter model)
{
try
{
return(Ok(await _kursInstancaService.GetMojiKursevi(UserResolver.GetUposlenikId(HttpContext.User), model)));
}
catch (Exception ex)
{
return(BadRequest(new ApiException(ex.Message, System.Net.HttpStatusCode.BadRequest)));
}
}
public async Task <ActionResult> ZavrsiInstancu(int id, [FromBody] bool postaviZaKlijenteKaoPolozili = true)
{
try
{
return(Ok(await _kursInstancaService.ZavrsiInstancu(UserResolver.GetUposlenikId(HttpContext.User), id, postaviZaKlijenteKaoPolozili)));
}
catch (Exception ex)
{
return(BadRequest(new ApiException(ex.Message, System.Net.HttpStatusCode.BadRequest)));
}
}
public async Task <ActionResult> GetForKlijent([FromQuery] DateTime?datumOd = null, [FromQuery] DateTime?datumDo = null)
{
try
{
return(Ok(await _uplataService.Get(UserResolver.GetKlijentId(HttpContext.User), datumOd, datumDo)));
}
catch (Exception ex)
{
return(BadRequest(new ApiException(ex.Message, System.Net.HttpStatusCode.BadRequest)));
}
}
public async Task <ActionResult> GetReport([FromBody] UplataFilterModel model)
{
try
{
return(Ok(await _uplataService.GetReport(UserResolver.GetUserRoles(HttpContext.User), UserResolver.GetUserId(HttpContext.User), model)));
}
catch (Exception ex)
{
return(BadRequest(new ApiException(ex.Message, System.Net.HttpStatusCode.BadRequest)));
}
}
public Migration(IConfiguration configuration, BucketPrefixProvider bucketPrefix, IForgeOSS forgeOSS, MigrationBucketKeyProvider bucketProvider, UserResolver userResolver, ProjectWork projectWork, ILogger <Migration> logger, ResourceProvider resourceProvider, OssBucketFactory bucketFactory, ProjectService projectService)
{
_forgeOSS = forgeOSS;
_configuration = configuration;
_bucketPrefix = bucketPrefix;
_bucketProvider = bucketProvider;
_userResolver = userResolver;
_projectWork = projectWork;
_logger = logger;
_resourceProvider = resourceProvider;
_bucketFactory = bucketFactory;
_projectService = projectService;
}
public async Task InvokeAsync(HttpContext context, UserResolver resolver, ILogger <RouteTokenHandler> logger)
{
string token = context.GetRouteValue("token") as string; // IMPORTANT: parameter name must be in sync with route definition
if (!string.IsNullOrEmpty(token))
{
logger.LogInformation("Extracted token from route");
resolver.Token = token;
}
// Call the next delegate/middleware in the pipeline
await _next(context);
}
/// <summary>
/// Constructor.
/// </summary>
public Initializer(ILogger <Initializer> logger, FdaClient fdaClient, IOptions <DefaultProjectsConfiguration> optionsAccessor,
ProjectWork projectWork, UserResolver userResolver, LocalCache localCache)
{
_logger = logger;
_fdaClient = fdaClient;
_projectWork = projectWork;
_userResolver = userResolver;
_localCache = localCache;
_defaultProjectsConfiguration = optionsAccessor.Value;
// bucket for anonymous user
_bucket = _userResolver.AnonymousBucket;
}
private void CreateDefaultApplicationUserServiceInstance()
{
var services = new ServiceCollection();
var mockStore = new Mock <IUserStore <ApplicationUser> >();
var mockOptionsAccessor = new Mock <IOptions <IdentityOptions> >();
var mockPasswordHasher = new Mock <IPasswordHasher <ApplicationUser> >();
var userValidators = new List <IUserValidator <ApplicationUser> >();
var validators = new List <IPasswordValidator <ApplicationUser> >();
var mockKeyNormalizer = new Mock <ILookupNormalizer>();
var mockErrors = new Mock <IdentityErrorDescriber>();
var mockServices = new Mock <IServiceProvider>();
var mockLogger = new Mock <ILogger <UserManager <ApplicationUser> > >();
var userManager = new UserManager <ApplicationUser>(mockStore.Object,
mockOptionsAccessor.Object,
mockPasswordHasher.Object,
userValidators,
validators,
mockKeyNormalizer.Object,
mockErrors.Object,
mockServices.Object,
mockLogger.Object);
var userResolver = new UserResolver(userManager, _mapper);
var bonusResolver = new BonusResolver(new Mock <IVendorService>().Object, new Mock <IBonusService>().Object, _mapper);
services.AddTransient(sp => userManager);
services.AddTransient(sp => userResolver);
services.AddTransient(sp => bonusResolver);
IServiceProvider serviceProvider = services.BuildServiceProvider();
var myProfile = new MapperProfile();
var configuration = new MapperConfiguration(cfg =>
{
cfg.AddProfile(myProfile);
cfg.ConstructServicesUsing(serviceProvider.GetService);
});
_mapper = new Mapper(configuration);
_random = new Random();
GenerateData();
CreateMock();
_userManager = _userManagerMock.Object;
_signManager = _signManagerMock.Object;
_tokenService = _tokenServiceMock.Object;
_userService = new UserService(_signManager, _userManager, _mapper, _fakeOptions, _tokenService);
}
public ProjectService(ILogger <ProjectService> logger, UserResolver userResolver, ProjectWork projectWork)
{
_logger = logger;
_userResolver = userResolver;
_projectWork = projectWork;
_waitForBucketPolicy = Policy
.Handle <ApiException>(e => e.ErrorCode == StatusCodes.Status404NotFound)
.WaitAndRetryAsync(
retryCount: 4,
retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)),
(exception, timeSpan) => _logger.LogWarning("Cannot get fresh OSS bucket. Repeating")
);
}
protected override OutputData ChangePasswd(UserResolver resolver, BasePasswordData passwd)
{
PasswordData password = passwd.Convert<PasswordData>();
bool success = resolver.ChangePassword(passwd.UserId, passwd.GetNewPassword("PasswordData"),
password.OldPassword);
if (success)
return OutputData.CreateToolkitObject(resolver.CreateKeyData());
else
{
const string errorMsg = "原密码不匹配";
FieldErrorInfo field = new FieldErrorInfo("PasswordData", "OldPassword", errorMsg);
throw new WebPostException(errorMsg, field);
}
}
public async Task <ActionResult> UpdateKlijentData([FromBody] KlijentDataUpdateModel model)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(model));
}
return(Ok(await _klijentDataService.UpdateKlijentData(UserResolver.GetKlijentId(HttpContext.User), model)));
}
catch (Exception ex)
{
return(BadRequest(new ApiException(ex.Message, System.Net.HttpStatusCode.BadRequest)));
}
}
public async Task <IActionResult> Insert(OrderInsertModel model)
{
try
{
await _orderSpecificService.Insert(model, UserResolver.GetUserId(HttpContext.User));
await _hubContext.Clients.All.SendAsync("RefreshMessage");
return(Ok());
}
catch
{
return(BadRequest());
}
}
public OutputData Insert(IInputData input, object instance)
{
LogOnData data = instance.Convert<LogOnData>();
using (UserResolver resolver = new UserResolver(this))
{
IUserInfo userInfo = resolver.CheckUserLogOn(data.LogOnName, data.Password, 0);
if (userInfo == null)
{
}
WebGlobalVariable.SessionGbl.AppRight.Initialize(userInfo);
var response = WebGlobalVariable.Response;
HttpCookie cookie = new HttpCookie(COOKIE_NAME, data.LogOnName)
{
Expires = DateTime.Now.AddDays(30)
};
response.Cookies.Set(cookie);
CookieUserInfo cookieInfo = new CookieUserInfo(data, userInfo);
cookie = new HttpCookie(RightConst.USER_INFO_COOKIE_NAME, cookieInfo.Encode())
{
Expires = GetExpireDate()
};
response.Cookies.Set(cookie);
WebSuccessResult result;
var request = WebGlobalVariable.Request;
string retUrl = request.QueryString["RetURL"];
if (!string.IsNullOrEmpty(retUrl))
result = new WebSuccessResult(retUrl);
else
{
WebAppSetting appSetting = WebAppSetting.WebCurrent;
if (string.IsNullOrEmpty(appSetting.MainPath))
result = new WebSuccessResult(appSetting.HomePath);
else
{
string url = HttpUtility.UrlEncode(appSetting.HomePath);
string mainUrl = UriUtil.AppendQueryString(appSetting.MainPath, "StartUrl=" + url);
result = new WebSuccessResult(mainUrl);
}
}
return OutputData.CreateToolkitObject(result);
}
}
protected abstract OutputData ChangePasswd(UserResolver resolver, BasePasswordData passwd);
protected override OutputData ChangePasswd(UserResolver resolver, BasePasswordData passwd)
{
resolver.ChangePassword(passwd.UserId,
passwd.GetNewPassword("PasswordData"), null);
return OutputData.CreateToolkitObject(resolver.CreateKeyData());
}
