public Either <IError, KeyDto> Authenticate(User user)
{
Message <UserMessage> message = new Message <UserMessage>("AuthenticateUser")
{
Data = new UserMessage()
{
Email = user.Email,
Password = user.Password
}
};
NetMQMessage response = RequestSocketFactory.SendRequest(message.ToNetMQMessage());
string responseTopic = response.First.ConvertToString();
if (responseTopic.Equals("Response"))
{
Message <TokenMessage> successMessage = new Message <TokenMessage>(response);
KeyDto keyDto = new KeyDto();
keyDto.Key = successMessage.Data.Token;
return(new Right <IError, KeyDto>(keyDto));
}
return(new Left <IError, KeyDto>(GetError(response)));
}
public async Task <IActionResult> Remove([FromBody] KeyDto keyDto)
{
if (!ModelState.IsValid)
{
return(this.ValidationError());
}
Application app = this.GetApplication();
ApplicationService service = await _context.Services.FirstOrDefaultAsync(serv => serv.Key == keyDto.Key);
if (service == null)
{
return(StatusCode((int)HttpStatusCode.Unauthorized));
}
List <ServiceEnvironment> envs =
await _context.Environments.Where(env => env.ServiceId == service.Id).ToListAsync();
IEnumerable <Task> removeConfigTasks =
envs.Select(async env => await _client.RemoveConfigsAsync(app.Key, service.Key, env.Key));
await Task.WhenAll(removeConfigTasks);
_context.Services.Remove(service);
await _context.SaveChangesAsync();
return(Ok());
}
public async Task <IActionResult> Login([FromBody] KeyDto keyDto)
{
if (!ModelState.IsValid)
{
return(this.ValidationError());
}
Application app = await GetApplication(keyDto.Key);
if (app == null)
{
return(StatusCode((int)HttpStatusCode.Unauthorized));
}
Dictionary <(Guid AppKey, Guid ServKey, Guid EnvKey), IEnumerable <string> > configs = await CollectConfigs(app);
return(Json(new {
ApplicationKey = app.Key,
ApplicationName = app.Name,
Services = app.Services.Select(serv => new {
ServiceKey = serv.Key,
ServiceName = serv.Name,
Environments = serv.Environments.Select(env => new {
EnvironmentKey = env.Key,
EnvironmentName = env.Name,
Configs = configs[(app.Key, serv.Key, env.Key)]
/// <summary>
/// Get value of key
/// </summary>
/// <param name="key"></param>
/// <returns>Value of key in string form</returns>
public Value GetValue(KeyDto key)
{
var res = _db.StringGet(key.KeyName);
return(new Value {
Data = res
});
}
private KeyDto CreateLink(KeyDto keyDto)
{
_hypermediaBuilder.CreateLink(keyDto, "GetKeyByUser", keyDto.Id, "selft", HypermediaVerbs.Get);
_hypermediaBuilder.CreateLink(keyDto, "DeleteKeyByUser", keyDto.Id, "delete_key", HypermediaVerbs.Delete);
_hypermediaBuilder.CreateLink(keyDto, "UpdateKeyByUser", keyDto.Id, "update_key", HypermediaVerbs.Put);
return(keyDto);
}
/// <summary>
/// Delete key
/// </summary>
/// <param name="key"></param>
/// <returns>True/False if key delete was success</returns>
public bool DeleteKey(KeyDto key)
{
if (key.Subset != null)
{
return(_db.KeyDelete($"{key.KeyName}#{key.Subset}#{key.OrgId}"));
}
else
{
return(_db.KeyDelete($"{key.KeyName}#{key.OrgId}"));
}
}
public void AddKey(KeyDto key)
{
dbContext.Keys.Add(new Key
{
SourceId = key.SourceId,
KeyValue = key.KeyValue,
ExpiryDate = key.ExpiryDate,
Count = key.Count,
IsDeactivated = false
});
dbContext.SaveChanges();
}
/// <summary>
/// 执行文件导入
/// </summary>
/// <param name="docDao"></param>
/// <param name="keyDao"></param>
/// <param name="cat"></param>
/// <param name="srcFile"></param>
/// <returns></returns>
private DocDto ImportImg(DocDao docDao, KeyDao keyDao, DocDto cat, string srcFile)
{
var name = Path.GetFileName(srcFile);
var dstFile = DocDto.Combine(cat.FullRelativeFile, name);
var docDto = new DocImgDto();
docDto.names = cat.GenDocName(name);
docDto.path = dstFile;
docDto.pid = cat.id;
docDto.Init(_Cfg);
var key = DocImgDto.GetFileHash(srcFile);
if (string.IsNullOrEmpty(key))
{
if (!docDto.ImportFile(srcFile, false))
{
return(null);
}
}
var keyDto = keyDao.Read(key);
if (keyDto == null)
{
keyDto = new KeyDto();
keyDto.names = name;
keyDto.key = key;
keyDto.qty = 1;
keyDto.file = dstFile;
keyDao.Save(keyDto);
if (!docDto.ImportFile(srcFile, false))
{
return(null);
}
}
else
{
keyDto.qty += 1;
keyDao.Change(keyDto.id, 1);
}
docDto.key = keyDto.id;
docDao.Save(docDto);
return(docDto);
}
public bool RegisterUser(string username, KeyDto pass, string privateKeyBase64)
{
//DynamicParameters obj = new DynamicParameters();
//obj.Add("@username", username);
//obj.Add("@email", "");
//obj.Add("@pass", pass.passHash);
//obj.Add("@salt", privateKeyBase64);
//obj.Add("@isAdmin", true);
object obj = new { username, email = "", pass = pass.passHash, salt = privateKeyBase64, isAdmin = true };
var g = _dp.Get <bool>("CreateNewUser", new DynamicParameters(obj), CommandType.Text);
//Von der Auswertung der Methode "Services.DapperrAuth.Insert(string, Dapper.DynamicParameters, System.Data.CommandType)" wird ein Aufruf in der nativen Methode "System.DateTime.GetSystemTimeWithLeapSecondsHandling(System.DateTime+FullSystemTime*)" ausgeführt. Das Auswerten nativer Methoden in diesem Kontext wird nicht unterstützt.
return(true);
}
/// <summary>
/// Get value of key
/// </summary>
/// <param name="key"></param>
/// <returns>Value of key in string form</returns>
public Value GetValue(KeyDto key)
{
if (key.Subset != null)
{
var res = _db.StringGet($"{key.KeyName}#{key.Subset}#{key.OrgId}");
return(new Value {
Data = res
});
}
else
{
var res = _db.StringGet($"{key.KeyName}#{key.OrgId}");
return(new Value {
Data = res
});
}
}
public IHttpActionResult Info(KeyDto dto)
{
ConsumerInfoResult rlt = new ConsumerInfoResult();
var csm = _context.Consumers.FirstOrDefault(c => c.Openid == dto.Openid);
if (csm == null)
{
rlt.Code = 404;
rlt.Msg = "没有数据";
return(Ok(rlt));
}
rlt.Code = 200;
rlt.Couponcode = csm.Couponcode;
rlt.Dadacode = csm.Dadacode;
return(Ok(rlt));
}
/// <summary>
/// Retrieve All keys
/// </summary>
/// <param name="pageNumber">Page number</param>
/// <param name="pageSize">Page size</param>
/// <returns>List of Keys</returns>
public PaginatedList <KeyDto> GetAllKeys(int?pageNumber, int pageSize)
{
var keys = _multiplexer.GetServer("redis-12388.c261.us-east-1-4.ec2.cloud.redislabs.com", 12388).Keys(0, pattern: "*", pageSize: 100000);
var keyList = new List <KeyDto>();
foreach (var key in keys)
{
// ex key: IsFeatureActive#ad_emit_events#1
// f1 === IsFeatureActive
// f2 === ad_emit_event
// f3? === 1
var keyString = key.ToString();
if (keyString.Split("#").Length == 3)
{
var f1 = keyString.Split("#")[0];
var f2 = keyString.Split("#")[1];
var f3 = keyString.Split("#")[2];
var keyObj = new KeyDto {
KeyName = f1, Subset = f2, OrgId = f3
};
keyList.Add(keyObj);
}
else if (keyString.Split("#").Length == 2)
{
var f1 = keyString.Split("#")[0];
var f3 = keyString.Split("#")[1];
var keyObj = new KeyDto {
KeyName = f1, Subset = "", OrgId = f3
};
keyList.Add(keyObj);
}
}
// Paginate
pageSize = 50;
return(PaginatedList <KeyDto> .Create(keyList.AsQueryable().OrderBy(k => k.KeyName), pageNumber ?? 1, pageSize));
}
public IActionResult GetValue([FromQuery] KeyDto key)
{
try
{
var res = _keysService.GetValue(key);
if (res == null)
{
return(NotFound());
}
return(Ok(res));
}
catch (Exception e)
{
return(BadRequest(e));
}
}
private void ValidateKeyDto(KeyDto key)
{
if (key.SourceId == null)
{
throw new ArgumentNullException("SourceId");
}
if (key.KeyValue == null)
{
throw new ArgumentNullException("KeyValue");
}
if (fileRepository.GetFile(key.SourceId) == null)
{
throw new ArgumentException("Provided SourceId is invalid");
}
key.ExpiryDate = key.ExpiryDate.ToString() == null?DateTime.Now.AddDays(10) : key.ExpiryDate;
key.Count = key.Count > 0 ? key.Count : 5;
}
/// <summary>
/// Retrieves a list of keys according to a Redis key pattern
/// </summary>
/// <param name="pattern">A Redis key pattern</param>
/// <param name="pageNumber">Page number</param>
/// <param name="pageSize">Page size</param>
/// <returns></returns>
public PaginatedList <KeyDto> GetKeyByQuery(string pattern, int?pageNumber, int pageSize)
{
var keyList = new List <KeyDto>();
foreach (var key in _server.Keys(0, pattern: pattern, pageSize: 100000))
{
var keyString = key.ToString();
var keyDto = new KeyDto {
KeyName = keyString
};
keyList.Add(keyDto);
}
// Paginate
pageSize = 50;
return(PaginatedList <KeyDto> .Create(keyList.AsQueryable().OrderBy(k => k.KeyName), pageNumber ?? 1, pageSize));
}
/// <summary>
/// Retrieve All keys
/// </summary>
/// <param name="pageNumber">Page number</param>
/// <param name="pageSize">Page size</param>
/// <returns>List of Keys</returns>
public PaginatedList <KeyDto> GetAllKeys(int?pageNumber, int pageSize)
{
var keyList = new List <KeyDto>();
foreach (var key in _keys)
{
var keyString = key.ToString();
var keyDto = new KeyDto {
KeyName = keyString
};
keyList.Add(keyDto);
}
// Paginate
pageSize = 50;
return(PaginatedList <KeyDto> .Create(keyList.AsQueryable().OrderBy(k => k.KeyName), pageNumber ?? 1, pageSize));
}
/// <summary>
/// Retrieves a list of keys according to a Redis key pattern
/// </summary>
/// <param name="pattern">A Redis key pattern</param>
/// <param name="pageNumber">Page number</param>
/// <param name="pageSize">Page size</param>
/// <returns></returns>
public PaginatedList <KeyDto> GetKeyByQuery(string pattern, int?pageNumber, int pageSize)
{
var server = _multiplexer.GetServer("redis-12388.c261.us-east-1-4.ec2.cloud.redislabs.com", 12388);
var keyList = new List <KeyDto>();
foreach (var key in server.Keys(0, pattern: pattern, pageSize: 100000))
{
var keyString = key.ToString();
if (keyString.Split("#").Length == 3)
{
var f1 = keyString.Split("#")[0];
var f2 = keyString.Split("#")[1];
var f3 = keyString.Split("#")[2];
var keyObj = new KeyDto {
KeyName = f1, Subset = f2, OrgId = f3
};
keyList.Add(keyObj);
}
else if (keyString.Split("#").Length == 2)
{
var f1 = keyString.Split("#")[0];
var f3 = keyString.Split("#")[1];
var keyObj = new KeyDto {
KeyName = f1, Subset = "", OrgId = f3
};
keyList.Add(keyObj);
}
}
// Paginate
pageSize = 50;
return(PaginatedList <KeyDto> .Create(keyList.AsQueryable().OrderBy(k => k.KeyName), pageNumber ?? 1, pageSize));
}
public async Task <IActionResult> Remove([FromBody] KeyDto keyDto)
{
if (!ModelState.IsValid)
{
return(this.ValidationError());
}
Application application = this.GetApplication();
ApplicationService service = this.GetService();
ServiceEnvironment environment = await _context.Environments.FirstOrDefaultAsync(env => env.Key == keyDto.Key);
if (environment == null)
{
return(StatusCode((int)HttpStatusCode.Unauthorized));
}
await _client.RemoveConfigsAsync(application.Key, service.Key, environment.Key);
_context.Environments.Remove(environment);
await _context.SaveChangesAsync();
return(Ok());
}
public IActionResult DeleteKey([FromQuery] KeyDto key)
{
try
{
var res = _keysService.DeleteKey(key);
if (res == false)
{
var errMessage = new { success = res, message = "Error deleting key / could not find key" };
return(NotFound(errMessage));
}
var message = new { success = res, message = $"Successfully deleted {key.KeyName}" };
return(Ok(message));
}
catch (Exception e)
{
return(BadRequest(e));
}
}
private void Accept_Click(object sender, RoutedEventArgs e)
{
try
{
ValidateInput();
}
catch (Exception ex)
{
ErrorPanel.Visibility = Visibility.Visible;
ErrorOutput.Text = ex.Message;
return;
}
this.Key = new KeyDto()
{
KeyValue = KeyInput.Text.Trim(),
ExpiryDate = DateInput.SelectedDate.Value.AddHours(DateTime.Now.Hour),
Count = Int32.Parse(CountInput.Text.Trim()),
SourceId = SelectedFile.SourceId
};
//consumers of this event must provide their own custom handler(s)
RaiseEvent(new RoutedEventArgs(AddKeyWindow.AcceptEvent, this));
}
public static Key ParseFromKeyDto(KeyDto keyDto)
{
var result = new Key(keyDto.UserEmail, keyDto.Appointment, keyDto.Used, keyDto.Value);
return(result);
}
public static void UpdateKey(this KeyDto keyDto, Key key)
{
keyDto.Used = key.Used;
}
public PaymentInfoCache(PaymentInfo paymentInfo, KeyDto keyDtoDto) :
base(paymentInfo.Amount, paymentInfo.Email, paymentInfo.Game)
{
KeyDto = keyDtoDto;
}
public static KeyDto ParseFromKey(Key key)
{
var result = new KeyDto(key.Used, key.Value, key.UserEmail, key.Appointment);
return(result);
}
public void AddKey(KeyDto key)
{
ValidateKeyDto(key);
fileRepository.AddKey(key);
}
/// <summary>
/// Delete key
/// </summary>
/// <param name="key"></param>
/// <returns>True/False if key delete was success</returns>
public bool DeleteKey(KeyDto key)
{
var keyString = key.KeyName;
return(_db.KeyDelete(keyString));
}
