public async Task <ActionResult> ChangePassword(ChangePasswordViewModel model)
{
string userId = User.Identity.GetUserId();
_logger.Info("User {0} requested a password change", userId);
if (!ModelState.IsValid)
{
return(View(model));
}
var result = await UserManager.ChangePasswordAsync(userId, model.OldPassword, model.NewPassword);
if (result.Succeeded)
{
var user = await UserManager.FindByIdAsync(userId);
if (user != null)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
}
_logger.Info("User {0} succeeded with a password change");
return(RedirectToAction("Index", new { Message = ManageMessageId.ChangePasswordSuccess }));
}
AddErrors(result);
return(View(model));
}
/// <summary>
/// Represent methods to converting TXT with containns Uri to XML format
/// </summary>
/// <param name="parser">Txt format parser</param>
/// <param name="logger">Logger</param>
/// <param name="storage">Storage</param>
/// <param name="provider">File provider</param>
public void ConvertToXML(IParser parser, IStorage storage, IProvider provider, ICustomLogger logger)
{
logger.Info("Started converting to XML");
IEnumerable <Uri> allUrls = provider.Load();
List <URL> urls = new List <URL>();
foreach (Uri item in allUrls)
{
urls.Add(parser.Parse(item));
}
XDocument document = new XDocument();
XElement urlAdresses = new XElement("urlAdresses");
foreach (URL url in urls)
{
urlAdresses.Add(CreateXmlNode(url));
}
document.Add(urlAdresses);
logger.Info("Ended convertind to XML, save file");
storage.Save(document);
}
/// <summary>
///
/// </summary>
/// <param name="context"></param>
/// <param name="cancellationToken">Propagates notification that operations should be canceled.</param>
/// <returns></returns>
public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
{
var time = Process.GetCurrentProcess().TotalProcessorTime;
_logger.Info($"CPU {time}");
var status = HealthStatus.Healthy;
if (time > TimeSpan.FromSeconds(10))
{
status = HealthStatus.Degraded;
}
if (time > TimeSpan.FromSeconds(40))
{
status = HealthStatus.Unhealthy;
}
var data = new Dictionary <string, object>
{
{ "Cpu usage", time }
};
var result = new HealthCheckResult(status, null, null, data);
return(await Task.FromResult(result));
}
/// <summary>
///
/// </summary>
/// <param name="context"></param>
/// <param name="cancellationToken">Propagates notification that operations should be canceled.</param>
/// <returns></returns>
public Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
{
var process = Process.GetCurrentProcess();
var bytes = process.PeakWorkingSet64;
var kilobytes = bytes / 1024;
var megabytes = kilobytes / 1024;
_logger.Info($"RAM {megabytes}");
var status = HealthStatus.Healthy;
if (megabytes > 400)
{
status = HealthStatus.Degraded;
}
if (megabytes > 1_000)
{
status = HealthStatus.Unhealthy;
}
var result = new HealthCheckResult(status, $"RAM {megabytes} megabytes");
return(Task.FromResult(result));
}
/// <summary>
/// Saving data to storage
/// </summary>
public void SaveDb()
{
_outputEnvironment.Write($"{Resource.EnterFileName}: ");
var fileName = _outputEnvironment.Read();
try
{
_fileService.SaveToFile(fileName);
_outputEnvironment.WriteLine(Resource.StorageSaved);
_logger.Info(Resource.StorageSaved);
}
catch (Exception e)
{
_logger.Error(e.Message, e);
}
}
public TestDbContext(ICustomLogger <TestDbContext> logger)
: base("name=connection")
{
this.Database.Log = sql =>
{
Debug.WriteLine(sql);
logger.Info(sql);
};
}
public string Get()
{
_logger.Info(new Dictionary <string, object>
{
{ "Controller", nameof(HeartbeatController) },
{ "Result", "Alive" }
});
return("Alive");
}
/// <summary>
/// Login if user don`t authorized or logout
/// </summary>
public void LoginLogout()
{
if (_authService.GetCurrentClient() != null)
{
if (_authService.Logout())
{
_outputEnvironment.WriteLine(Resource.LogoutSuccess);
_logger.Info(Resource.LogoutSuccess);
}
else
{
_outputEnvironment.WriteLine(Resource.CannotLogout);
_logger.Info(Resource.CannotLogout);
}
return;
}
_outputEnvironment.Write($"{Resource.EnterFirstName}: ");
var firstName = _outputEnvironment.Read();
_outputEnvironment.Write($"{Resource.EnterLastName}: ");
var lastName = _outputEnvironment.Read();
var client = new ClientDto
{
FirstName = firstName,
LastName = lastName
};
if (_authService.Login(client))
{
_outputEnvironment.WriteLine(Resource.LoginSuccess);
_logger.Info(Resource.LoginSuccess);
}
else
{
_outputEnvironment.WriteLine(Resource.ClientNotExist);
_logger.Info(Resource.ClientNotExist);
}
}
private static void Main()
{
_customLogger = _container.GetInstance<ICustomLogger>();
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_HandleException;
ServiceBase[] servicesToRun =
{
new SchedulerService(_customLogger)
};
_customLogger.Info("Starting scheduler service..");
ServiceBase.Run(servicesToRun);
}
/// <summary>
///
/// </summary>
/// <param name="request"></param>
/// <param name="cancellationToken">Propagates notification that operations should be canceled.</param>
/// <param name="next"></param>
/// <returns></returns>
public Task <TResponse> Handle(TRequest request, CancellationToken cancellationToken, Func <TRequest, CancellationToken, Task <TResponse> > next)
{
var name = typeof(TRequest).Name;
_timer.Start();
var response = next(request, cancellationToken);
_timer.Stop();
_customLogger.Info($"TimerBehaviour: {name} ({_timer.ElapsedMilliseconds} milliseconds) {_identityService.UserId} {request}");
return(response);
}
public async Task Invoke(DownstreamContext context)
{
//保存请求的信息
BaseLogModel logModel = new BaseLogModel()
{
Type = 1,
Content = GetLogConent(context.HttpContext),
ServiceName = _logOptions.ServiceName
};
_log.Info <BaseLogModel>(logModel);
await _next(context);
}
public ActionResult AddAlbum()
{
if (!_userService.UserAlloweUploadAlbums(User.Identity.GetUserId()))
{
_logger.Info(Errors.AlbumLimitReached);
return(View("Error", Errors.AlbumLimitReached));
}
return(View(new AddAlbumViewModel()));
}
public ActionResult Search(string keyWord, string returnUrl)
{
_logger.Info("Search for keyword {0} from page {1}", keyWord, returnUrl);
if (!string.IsNullOrEmpty(keyWord))
{
SearchResult response = _searchService.BasicSearch(keyWord);
SearchResultViewModel result = MapperHelper.GetValue <SearchResult, SearchResultViewModel>(response);
_logger.Info("Search for keyword {0} is succeeded with {1} results", keyWord,
(result.Albums.Count + result.Photos.Count + result.Users.Count).ToString());
TempData["SearchResult"] = result;
return(RedirectToAction("SearchResult"));
}
return(Redirect(returnUrl));
}
public Task <Guid> Handle(CreateProductWithReturnCommand command, CancellationToken cancellationToken)
{
var newProduct = Product.Create(command.Id);
_productRepository.Add(newProduct);
var registersCreated = _productRepository.SaveChanges(); // Here you can do UnitOfWork and will save
if (registersCreated > 0)
{
_customLogger.Info("Product created: " + newProduct);
}
// TODO: Here will launch a event when the events work in SharedKernel
//return _eventBus.Publish(productCreate.PullDomainEvents(), cancellationToken);
return(Task.FromResult(newProduct.Id));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="httpContextAccessor"></param>
/// <param name="logger"></param>
public HttpContextAccessorIdentityService(
IHttpContextAccessor httpContextAccessor,
ICustomLogger <HttpContextAccessorIdentityService> logger)
{
if (httpContextAccessor == null)
{
logger.Info("IHttpContextAccessor not registered");
return;
}
User = httpContextAccessor.HttpContext?.User;
var request = httpContextAccessor.HttpContext?.Request;
if (request != default)
{
BasePath = $"{request.Scheme}://{request.Host}{request.PathBase}";
UserAgent = request.Headers["User-Agent"].ToString();
}
RemoteIpAddress = httpContextAccessor.HttpContext?.Connection.RemoteIpAddress?.ToString();
}
/// <summary>
/// 返回错误格式
/// </summary>
/// <param name="context"></param>
/// <param name="statusCode"></param>
/// <param name="msg"></param>
/// <returns></returns>
private Task HandleExceptionAsync(HttpContext context, int statusCode, string msg)
{
ErrorResultModel errorModel = new ErrorResultModel()
{
Message = msg,
Code = statusCode,
RequestUri = context.Request.GetAbsoluteUri()
};
BaseLogModel logModel = new BaseLogModel()
{
ServiceName = _logOptions.ServiceName,
Type = 4,
Content = msg
};
//增加到日志
_log.Info <BaseLogModel>(logModel);
var result = JsonConvert.SerializeObject(new { error = errorModel });
context.Response.ContentType = "application/json;charset=utf-8";
return(context.Response.WriteAsync(result));
}
private void ExecutedEvent(string sqlcommand)
{
_logger.Info <BaseLogModel>(GetLogModel(sqlcommand));
}
public BaseResultDto <List <PlayerSeasonStatisticsDto> > GetPlayers(IEnumerable <SeasonDto> seasons)
{
var result = new BaseResultDto <List <PlayerSeasonStatisticsDto> >();
var players = new List <PlayerSeasonStatisticsDto>();
result.Status = true;
var dataPath = Utility.GetApplicationSetting <string>("PathToDataFiles");
foreach (var season in seasons)
{
var pythonResult = PythonUtility.ExecutePythonScript(new PythonRequestDto
{
Command = Utility.GetApplicationSetting <string>("PlayerScript"),
Params = new string[] { season.StartYear.ToString(), season.League.Name }
});
if (pythonResult.Status)
{
var fname = result.DataObject;
var data = Utility.GetFileData(dataPath + pythonResult.Output);
foreach (var line in data.Skip(1))
{
var lineAsList = Utility.CsvRowToList(line);
int externalId = 0;
int assists = 0;
int bps = 0;
int cs = 0;
int goals = 0;
int og = 0;
int pm = 0;
int rc = 0;
int yc = 0;
int min = 0;
int apps = 0;
Constants.PositionEnum pos;
double xa = 0.0;
double xa90 = 0.0;
double xg = 0.0;
double xg90 = 0.0;
double cost = 0.0;
var parseStatus = int.TryParse(lineAsList[0], out externalId);
parseStatus &= int.TryParse(lineAsList[1], out assists);
parseStatus &= int.TryParse(lineAsList[2], out bps);
parseStatus &= int.TryParse(lineAsList[3], out cs);
parseStatus &= Enum.TryParse(lineAsList[4], out pos);
parseStatus &= int.TryParse(lineAsList[5], out goals);
parseStatus &= double.TryParse(lineAsList[7].Replace(".", ","), out cost);
parseStatus &= int.TryParse(lineAsList[8], out og);
parseStatus &= int.TryParse(lineAsList[9], out pm);
parseStatus &= int.TryParse(lineAsList[10], out rc);
parseStatus &= int.TryParse(lineAsList[11], out yc);
parseStatus &= int.TryParse(lineAsList[15], out apps);
parseStatus &= int.TryParse(lineAsList[16], out min);
parseStatus &= double.TryParse(lineAsList[20].Replace(".", ","), out xa);
parseStatus &= double.TryParse(lineAsList[22].Replace(".", ","), out xa90);
parseStatus &= double.TryParse(lineAsList[19].Replace(".", ","), out xg);
parseStatus &= double.TryParse(lineAsList[21].Replace(".", ","), out xg90);
cost /= 10;
if (parseStatus)
{
if (lineAsList[12] == "Teemu Pukki")
{
var t = 1;
}
var playerStatisticsDto = new PlayerSeasonStatisticsDto
{
Player = new PlayerDto
{
ExternalId = externalId,
Name = lineAsList[12],
SecondName = "",
LastCost = cost,
Position = pos
},
SeasonTeam = new SeasonTeamDto
{
Season = season,
Team = new TeamDto
{
Name = ConvertDoubleTeam(lineAsList[14])
}
},
Assists = assists,
BonusPointSystem = bps,
CleanSheets = cs,
Goals = goals,
OwnGoals = og,
PenaltiesMissed = pm,
RedCards = rc,
XA = xa,
XA90 = xa90,
XG = xg,
XG90 = xg90,
YellowCards = yc,
MinutesPlayed = min,
Apps = apps
};
players.Add(playerStatisticsDto);
}
else
{
_logger.Info($"Couldnt parse line: {line}");
}
}
}
}
result.DataObject = players;
return(result);
}
public ActionResult UploadPhoto(UploadPhotoViewModel model, HttpPostedFileBase image = null)
{
if (ModelState.IsValid)
{
if (image != null)
{
if (image.ContentLength < ConfigurationElements.MaxFileSize * ConfigurationElements.ModifierForMaxSize)
{
model.ImageMimeType = image.ContentType;
if (model.ImageMimeType.ToLower().Contains("image/jpeg"))
{
string userId = User.Identity.GetUserId();
_logger.Info("User {0} attempts to add a new photo", userId);
model.UniqueUserName = _userService.GetUniqueUserNameById(userId);
var request = new RequestEntity
{
PhotoName = model.PhotoName,
UniqueUserName = model.UniqueUserName
};
if (!_photoService.CheckIfPhotoExists(request))
{
model.MiniatureImageData = new byte[image.ContentLength];
image.InputStream.Read(model.MiniatureImageData, 0, image.ContentLength);
model.MidSizeImageData = model.MiniatureImageData;
model.SourceImageData = model.MiniatureImageData;
var uploadRequest = MapperHelper.GetValue <UploadPhotoViewModel, Photo>(model);
_photoService.UploadPhoto(uploadRequest);
_logger.Info("User {0} successfully added photo", userId);
TempData["ResultMessage"] = string.Format(SuccessMessages.SuccessfullyUploadedPhoto, model.PhotoName);
return(RedirectToAction("ViewPhoto", new { uniqueUserName = model.UniqueUserName, photoName = model.PhotoName }));
}
else
{
ModelState.AddModelError("AlreadyExists", "Photo with such name already exists in your collection");
}
}
else
{
ModelState.AddModelError("MimeType", "Wrong type, should be jpeg");
}
}
else
{
ModelState.AddModelError("Size", "The file is too big");
}
}
else
{
ModelState.AddModelError("NoPic", "There is no photo");
}
}
return(View(model));
}
public IActionResult Index()
{
_logger.Info("Index page opened");
return(View());
}
