public void Store(GenericResults results)
{
var fileName = ResolveFile(results.Date);
var rawContent = JsonConvert.SerializeObject(results);
File.WriteAllText(fileName, rawContent);
}
public static GenericResults Filter(this GenericResults results, string owner = null, string group = null, string environment = null, string service = null)
{
try
{
if (results != null && results.Results != null)
{
var filteredResults = results.Results.Where(
x => x != null && (x.Owner == owner || string.IsNullOrWhiteSpace(owner)) &&
(x.Group == group || string.IsNullOrWhiteSpace(group)) &&
(x.Environment == environment || string.IsNullOrWhiteSpace(environment)) &&
(x.Name == service || string.IsNullOrWhiteSpace(service)))
.ToList();
return(new GenericResults
{
Date = results?.Date ?? DateTime.Now,
Results = filteredResults
});
}
return(results);
}
catch
{
return(null);
}
}
public void Store(GenericResults results)
{
ObjectCache cache = MemoryCache.Default;
CacheItemPolicy policy = new CacheItemPolicy {
AbsoluteExpiration = new DateTimeOffset(DateTime.Now.AddDays(1))
};
cache.Set(CacheKeyServices, results, policy);
}
public GenericResults <InsertBookModel> SaveModel(InsertBookModel model, List <string> imageUrls)
{
var db_book = _bookRepository.GetByISBN13(model.ISBN13);
GenericResults <InsertBookModel> genericModel = new GenericResults <InsertBookModel>();
if (db_book != null)
{
genericModel.AddError(ErrorMessageCode.BookAlreadyExists, "ISBN13 Numarası zaten daha önce kayıt edilmiş!");
return(genericModel);
}
var IsbnCheck = IsDigitsOnly(model.ISBN13);
if ((!IsbnCheck) || model.ISBN13.Length != 13)
{
genericModel.AddError(ErrorMessageCode.WrongFormat, "ISBN13 Barkod numarası sadece rakam içermesi gerekir ve 13 rakamdan oluşmalıdır");
return(genericModel);
}
Book entity = new Book
{
Title = model.Title,
Description = model.Description,
PublicationDate = model.PublicationDate,
Price = model.Price,
ISBN13 = model.ISBN13,
Page = model.Page,
PublisherId = model.PublisherId,
AuthorId = model.AuthorId,
Stock = model.Stock
};
var generatedBookId = _bookRepository.Save(entity);
if (generatedBookId == 0)
{
genericModel.AddError(ErrorMessageCode.SomethingWentWrong, "Bir Hata oluştu. Lütfen tekrar deneyiniz!");
return(genericModel);
}
int imageResult = this.InsertBookImages(imageUrls, generatedBookId);
var bookCategories = string.Join(",", model.CategoryIds);
int categoryResult = _bookRepository.SaveBookCategories(bookCategories, generatedBookId);
if (imageResult == 0 || categoryResult == 0)
{
genericModel.AddError(ErrorMessageCode.SomethingWentWrong, "Bir Hata oluştu. Lütfen tekrar deneyiniz!");
return(genericModel);
}
return(genericModel);
}
public static EnvironmentResults AsEnvironmentResults(this GenericResults results)
{
var groupResults = new EnvironmentResults {
Date = results.Date
};
foreach (var genericResult in results.Results)
{
groupResults.GetOrAddEnvironment(genericResult.Environment)
.GetOrAddGroup(genericResult.Group)
.GetOrAddService(genericResult.Name, genericResult.Status);
}
return(groupResults);
}
public static GroupResults AsGroupResults(this GenericResults results)
{
var groupResults = new GroupResults {
Date = results.Date
};
foreach (var genericResult in results.Results)
{
groupResults.GetOrAddGroup(genericResult.Group)
.GetOrAddService(genericResult.Name)
.GetOrAddResult(genericResult.Environment, genericResult.Status);
}
groupResults.SetEnvironmentSummary();
return(groupResults);
}
public static OwnerResults AsOwnerResults(this GenericResults results)
{
var ownerResult = new OwnerResults {
Date = results.Date
};
foreach (var genericResult in results.Results)
{
ownerResult.GetOrAddOwner(genericResult.Owner)
.GetOrAddGroup(genericResult.Group)
.GetOrAddService(genericResult.Name)
.GetOrAddResult(genericResult.Environment, genericResult.Status);
}
ownerResult.SetEnvironmentSummary();
return(ownerResult);
}
public static GenericResults UploadFilesInDirectory(string remoteDirectory, string localDirectory, string localSearchPattern = "*")
{
var result = new GenericResults();
try
{
// Returns the names of files (including their paths)
string[] filePathList = Directory.GetFiles(localDirectory, localSearchPattern, SearchOption.TopDirectoryOnly);
if (!filePathList.Any())
{
Log.Debug("UploadFilesInDirectory - No files found in the directory {0}.", localDirectory);
result.ErrorMessages.Add("No files to be upload.");
return(result);
}
using (var sftp = new SftpClient(GetConnectionInfo()))
{
sftp.Connect();
foreach (var filePath in filePathList)
{
string remoteFileNamePath = Path.Combine(remoteDirectory, Path.GetFileName(filePath));
if (InternalUploadFile(sftp, remoteFileNamePath, filePath, out string errorMessage))
{
result.SuccessCount += 1;
}
else
{
result.ErrorCount += 1;
result.ErrorMessages.Add(errorMessage);
}
}
sftp.Disconnect();
}
}
catch (Exception ex)
{
Log.Error("UploadFilesInDirectory Error", ex);
result.ErrorMessages.Add("System Error");
}
return(result);
}
private GenericResults LoadAsync(IList <Setting> settings)
{
try
{
Log.Logger.Information("Getting states...");
var result = new GenericResults()
{
Date = DateTime.Now
};
Parallel.ForEach(settings, test => Execute(test, result));
Log.Logger.Information("All states retreived");
return(result);
}
catch
{
Log.Logger.Error("Something went wrong...");
}
return(null);
}
public GenericResults <Publisher> SaveModel(Publisher model)
{
var db_publisher = _publisherRepository.CheckByName(model.Name);
GenericResults <Publisher> genericModel = new GenericResults <Publisher>();
if (db_publisher != null)
{
genericModel.AddError(ErrorMessageCode.PublisherAlreadyExists, "Bu Yayınevi zaten sistemde Kayıtlı!");
return(genericModel);
}
genericModel.Model = this.PrepareEntity(model);
int result = _publisherRepository.Save(genericModel.Model);
if (result == 0)
{
genericModel.AddError(ErrorMessageCode.SomethingWentWrong, "Bir hata oluştu. Lütfen Tekrar Deneyiniz!");
}
return(genericModel);
}
public GenericResults <Author> SaveModel(Author model)
{
var db_author = _authorRepository.CheckByName(model.Name);
GenericResults <Author> updateModel = new GenericResults <Author>();
if (db_author != null)
{
updateModel.AddError(ErrorMessageCode.AuthorAlreadyExists, "Bu yazar zaten sistemde Kayıtlı!");
return(updateModel);
}
updateModel.Model = this.PrepareEntity(model);
int result = _authorRepository.Save(updateModel.Model);
if (result == 0)
{
updateModel.AddError(ErrorMessageCode.SomethingWentWrong, "Bir hata oluştu. Lütfen Tekrar Deneyiniz!");
}
return(updateModel);
}
public GenericResults <Category> SaveModel(Category model)
{
var db_category = _categoryRepository.CheckByName(model.Title);
GenericResults <Category> updateModel = new GenericResults <Category>();
if (db_category != null)
{
updateModel.AddError(ErrorMessageCode.CategoryALreadyExists, "Bu kategori daha önce kayıt edilmiş!");
return(updateModel);
}
updateModel.Model = this.PrepareEntity(model);
int result = _categoryRepository.Save(updateModel.Model);
if (result == 0)
{
updateModel.AddError(ErrorMessageCode.SomethingWentWrong, "Bir şeyler yanlış gitti. Tekrar deneyiniz!");
}
return(updateModel);
}
public void Handle(Setting test, GenericResults genericResults)
{
try
{
var list = GetProcesses(test);
if (list != null)
{
foreach (var processInformation in list)
{
var result = test.AsGenericResult();
result.Name = processInformation.Identifier;
result.Status = processInformation.State == "Idle" | processInformation.State == "Running"
? StatusType.Up
: StatusType.Down;
genericResults.Results.Add(result);
}
}
}
catch
{
//Log.Error($"Error while trying to execute on {test.Environment}-{test.Service}");
}
}
public void Handle(Setting test, GenericResults genericResults)
{
genericResults.Results.Add(IsAlive(test));
}
private void Execute(Setting setting, GenericResults results)
{
_handlers[setting.Type].Handle(setting, results);
}
