public Task <IActionResult> TakeAToken(TakeATokenModel model)
{
return(this.ResultAsync(async() =>
{
Guid?ret = null;
if (model.IsModelValid() && model.Password == "You are right boss")
{
IAuthModel auth = await this.Db.Authes.GetBy(model.Address);
if (null == auth)
{
auth = this.Db.ModelFactory.CreateAuthModel();
auth.Address = model.Address;
auth.Token = Guid.NewGuid();
await this.Db.Authes.Save(auth);
}
++auth.LoginCount;
await this.Db.Authes.EditLoginCount(auth.AuthId, auth.LoginCount);
ret = auth.Token;
}
return ret;
}));
}
public HEADER(Type AuthModelType)
{
if (AuthModelType == null)
{
throw new ArgumentNullException(nameof(AuthModelType));
}
object Instance = default;
try
{
Instance = Activator.CreateInstance(AuthModelType);
}
catch
{
throw new ArgumentException($"make sure that {nameof(AuthModelType)} has default constructor");
}
if (!AuthModelType.IsAssignableFrom(typeof(IAuthModel)) && AuthModelType.GetInterface(nameof(IAuthModel)) == null)
{
throw new ArgumentException($"{nameof(AuthModelType)} does not implement {typeof(IAuthModel)}");
}
Key = "Authorization";
Value = string.Empty;
_authModelType = AuthModelType;
authModel = ((IAuthModel)Instance).Create();
}
//Get token
//Input: user_id, email, role
//Output: JWT
public static string getToken(string user_id, string email, string role)
{
IAuthModel model = GetJWTModel(user_id, email, role);
IAuthService authService = new JWTService(model.PrivateKey, model.PublicKey);
string token = authService.GenerateToken(model);
if (!authService.IsTokenValid(token))
{
return("false");
}
return(token);
}
/// <summary>
/// Generates token by given model.
/// Validates whether the given model is valid, then gets the symmetric key.
/// Encrypt the token and returns it.
/// </summary>
/// <param name="model"></param>
/// <returns>Generated token.</returns>
public string GenerateToken(IAuthModel model)
{
if (model == null || model.Claims == null || model.Claims.Length == 0)
{
throw new ArgumentException("Arguments to create token are not valid.");
}
SecurityTokenDescriptor securityTokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(model.Claims),
Expires = DateTime.UtcNow.AddMinutes(Convert.ToInt32(model.ExpireMinutes)),
SigningCredentials = new SigningCredentials(GetPrivateKey(model.PrivateKey), model.SecurityAlgorithm)
};
JwtSecurityTokenHandler jwtSecurityTokenHandler = new JwtSecurityTokenHandler();
SecurityToken securityToken = jwtSecurityTokenHandler.CreateToken(securityTokenDescriptor);
string token = jwtSecurityTokenHandler.WriteToken(securityToken);
return(token);
}
public async Task <IAuthModel> Save(IAuthModel auth)
{
if (null == auth || String.IsNullOrEmpty(auth.Address))
{
return(null);
}
// await this.Db.Authes.ReplaceOrInsertOneAsync((m) => m.Address == auth.Address, (Auth)auth);
Auth exist = await this.Db.Authes.AsQueryable().FirstOrDefaultAsync(p => p.Address == auth.Address);
if (null != exist)
{
await this.Db.Authes.ReplaceOrInsertOneAsync(exist);
}
else
{
await this.Db.Authes.InsertOneAsync((Auth)auth);
}
return(auth);
}
public ServiceCentreViewModel(IAuthModel model, IServiceModel serviceModel, IExrinContainer exrinContainer) :
base(model, exrinContainer, new ServiceCentreVisualState(serviceModel))
{
}
public ServiceViewModel(IAuthModel authModel, IServiceModel model, IExrinContainer exrinContainer) :
base(authModel, exrinContainer, new ServiceVisualState(model))
{
Model = model;
}
public ServiceModel(IExrinContainer exrinContainer, IServiceService serviceService, IAuthModel authModel)
: base(exrinContainer, new ServiceModelState())
{
_serviceService = serviceService;
}
public LoginOperation(IAuthModel authModel)
{
_authModel = authModel;
}
public ControlModel(IExrinContainer exrinContainer, IAuthModel authModel)
: base(exrinContainer, new ControlModelState())
{
_authModel = authModel;
}
public MainViewModel(IAuthModel authModel, IExrinContainer exrinContainer) :
base(authModel, exrinContainer, null)
{
}
public BaseViewModel(IAuthModel authModel, IExrinContainer exrinContainer, IVisualState visualState, [CallerFilePath] string caller = nameof(BaseViewModel))
: base(exrinContainer, visualState, caller)
{
AuthModel = authModel; Init();
}
public PinLoginOperation(IAuthModel model, string backCharacter)
{
_model = model;
_backCharacter = backCharacter;
}
public PinViewModel(IAuthModel model, IExrinContainer exrinContainer) :
base(model, exrinContainer, new PinVisualState(model))
{
}
public ProfileID(IAuthModel authModel)
{
_authModel = authModel;
}
public ControlViewModel(IAuthModel authModel, IControlModel model, IExrinContainer exrinContainer) :
base(authModel, exrinContainer, new ControlVisualState(model))
{
Model = model;
}
public AuthWindowViewModel(IAuthModel model) => this.Model = model;
public ListViewModel(IAuthModel model) :
base(new ListVisualState(model))
{
_model = model;
}
public DetailViewModel(IAuthModel model) :
base(new DetailVisualState(model))
{
_model = model;
}
public ClimateModel(IExrinContainer exrinContainer, IAuthModel authModel, IClimateService service)
: base(exrinContainer, new ClimateModelState())
{
_service = service;
}
public LoginViewModel(IAuthModel model, IExrinContainer exrinContainer) :
base(exrinContainer, new LoginVisualState(model))
{
_model = model;
}
public PinVisualState(IAuthModel model) : base(model)
{
}
public ClimateViewModel(IAuthModel authModel, IClimateModel model, IExrinContainer exrinContainer) :
base(authModel, exrinContainer, new ClimateVisualState(model))
{
_model = model;
_container = exrinContainer;
}
public PinLoginViewModelExecute(IAuthModel model, string backCharacter)
{
TimeoutMilliseconds = 10000;
Operations.Add(new PinLoginOperation(model, backCharacter));
}
public BookingViewModel(IAuthModel model, IServiceModel serviceModel, IExrinContainer exrinContainer) :
base(model, exrinContainer, new BookingVisualState(serviceModel))
{
}
public MainModel(IExrinContainer exrinContainer, IAuthModel authModel)
: base(exrinContainer, null)
{
}
