public static string CreateDailyMessage(string groupName, WeekType week, int day)
{
var repository = new ServerStorageRepository();
var localRepo = new LocalStorageRepository();
var lessonList = repository.GetLessonList(groupName, day, week);
var localList = localRepo.GetLessonList(groupName, day, week);
var msg = AnswerGeneratorService.GenerateHeader(week, day);
if (lessonList.Except(localList).Any())
{
msg += "❌ ИСУ вернула расписание, отличное от локального\n"
+ "С ИСУ:\n" + string.Join("\n", lessonList.Select(AnswerGeneratorService.LessonToString))
+ "\nЛокально:\n" + string.Join("\n", localList.Select(AnswerGeneratorService.LessonToString));
}
else if (!lessonList.Any())
{
msg += AnswerGeneratorService.NoLessonMessage();
}
else
{
msg += string.Join("\n", lessonList.Select(AnswerGeneratorService.LessonToString));
}
return(msg);
}
public void UpdateLocalData(string group)
{
var localStorage = new LocalStorageRepository();
var storage = new ServerStorageRepository();
localStorage.Update(group, storage.GetLessonList(group));
}
private async Task <T> ProcessDirectoryChanges <T>(T item) where T : FileSystemItem
{
var serializedDirectory = new FileSystemDirectorySerializer().Serialize(FileSystemItems.Values.Where(p => p.HasParent));
await LocalStorageRepository.SetItem(LocalStorageDirectoryFileName, serializedDirectory);
DirectoryChanged?.Invoke(this, EventArgs.Empty);
return(item);
}
public void Setup(CommandLine commandLine)
{
_appConfigFilePath = commandLine.AppConfigFilePath;
_configRepos = _dic.GetInstance <LocalStorageRepository <AppConfig> >().Setup(_appConfigFilePath);
_appConfig.Load(_configRepos);
}
public async Task <IEnumerable <IFavoriteItem> > GetFavorites()
{
if (Items == null)
{
Items = new FavoriteSerializer().Deserialize(await LocalStorageRepository.GetItem(LocalStorageFavoritesName)).ToList();
}
return(Items.ToArray());
}
private async Task <FavoriteItem> ProcessChanges(FavoriteItem item, Func <FavoriteItem, List <FavoriteItem>, IEnumerable <FavoriteItem> > action)
{
await GetFavorites();
Items = action(item, Items).ToList();
var serializedFavorites = new FavoriteSerializer().Serialize(Items);
await LocalStorageRepository.SetItem(LocalStorageFavoritesName, serializedFavorites);
FavoritesChanged?.Invoke(this, EventArgs.Empty);
return(item);
}
public async Task <string> GetFileContent(Guid fileKey)
{
string content;
if (!FileContent.TryGetValue(fileKey, out content))
{
content = await LocalStorageRepository.GetItem(LocalStorageFileNameTemplate + fileKey.ToString());
FileContent.Add(fileKey, content ?? String.Empty);
}
return(content);
}
public async Task Initialize(LocalStorageRepository localStorageRepository)
{
if (localStorageRepository == null)
{
throw new ArgumentNullException(nameof(localStorageRepository));
}
if (_Model != null)
{
throw new InvalidOperationException("Already initialized");
}
_Model = new AppViewModel(localStorageRepository);
await _Model.Initialize();
}
private async Task EnsureInitialized()
{
if (!IsInitialized)
{
try
{
var serializedDirectory = await LocalStorageRepository.GetItem(LocalStorageDirectoryFileName);
if (!String.IsNullOrWhiteSpace(serializedDirectory))
{
var dtos = new FileSystemDirectorySerializer().Deserialize(serializedDirectory).ToList();
await RestoreFromDto(dtos, RootFolder.Key);
}
}
catch (Exception ex)
{
Logger.LogError(ex, "Initialization error");
}
IsInitialized = true;
}
}
public AppViewModel(LocalStorageRepository localStorageRepository)
{
if (localStorageRepository == null)
{
throw new ArgumentNullException(nameof(localStorageRepository));
}
LocalStorageRepository = localStorageRepository;
FileSystemRepository = new FileSystemRepository(localStorageRepository);
FavoriteRepository = new FavoriteRepository(localStorageRepository);
ConfigRepository = new ConfigRepository(localStorageRepository);
InputStreamItem = new WorkspaceItemModel(FileSystemRepository.InputStream.Key, WorkspaceItemKindEnum.InputStream, FileSystemRepository.InputStream.Name);
CommandExecutionModel = new CommandExecutionModel(
FileSystemRepository,
getSourceKey: () => Selected,
addCommandToHistory: AddCommandToHistory,
getEnvironmentalConfig: GetEnvironmentalConfig,
saveTextEditorContent: SaveTextEditorContent
);
}
public async Task <CommandHistoryList> GetCommandHistoryList()
{
return(new ConfigSerializer().DeserializeCommandHistoryList(await LocalStorageRepository.GetItem(LocalStorageCommandHistoryList)));
}
public async Task SetFileContent(Guid fileKey, string content)
{
FileContent[fileKey] = content;
await LocalStorageRepository.SetItem(LocalStorageFileNameTemplate + fileKey.ToString(), content);
}
public async Task SetViewConfig(ViewConfig viewConfig)
{
await LocalStorageRepository.SetItem(LocalStorageViewConfig, new ConfigSerializer().SerializeViewConfig(viewConfig));
}
public async Task SetEnvironmentalConfig(EnvironmentalConfig environmentalConfig)
{
await LocalStorageRepository.SetItem(LocalStorageEnvironmentalConfig, new ConfigSerializer().SerializeEnvironmentalConfig(environmentalConfig));
}
public async Task SetCommandHistoryList(CommandHistoryList commandHistoryList)
{
await LocalStorageRepository.SetItem(LocalStorageCommandHistoryList, new ConfigSerializer().SerializeCommandHistoryList(commandHistoryList));
}
public async Task <ViewConfig> GetViewConfig()
{
return(new ConfigSerializer().DeserializeViewConfig(await LocalStorageRepository.GetItem(LocalStorageViewConfig)));
}
public async Task <EnvironmentalConfig> GetEnvironmentalConfig()
{
return(new ConfigSerializer().DeserializeEnvironmentalConfig(await LocalStorageRepository.GetItem(LocalStorageEnvironmentalConfig)));
}
