public IActionResult GetLatestAssets()
{
var viewModel = new AutoForecastViewModel();
try
{
var manager = new DirectoryManager(_appSettings, currentLocation);
var folder = manager.GetLastFolder(DirSwitcher.Auto);
var positiveDir = Path.Combine(folder, manager.DirPositive);
var neutralDir = Path.Combine(folder, manager.DirNeutral);
var negativeDir = Path.Combine(folder, manager.DirNegative);
var strongPositiveDir = Path.Combine(folder, manager.DirStrongPositive);
var pathToExcelLog = Path.Combine(folder, StaticUtility.LogName);
viewModel.PositiveAssets = DirectoryManager.GetFolderNames(positiveDir);
viewModel.NeutralAssets = DirectoryManager.GetFolderNames(neutralDir);
viewModel.NegativeAssets = DirectoryManager.GetFolderNames(negativeDir);
viewModel.StrongPositiveAssets = DirectoryManager.GetFolderNames(strongPositiveDir);
viewModel.Report = manager.ReadLog(pathToExcelLog);
}
catch (Exception e)
{
return(NotFound(new { message = e.Message }));
}
return(Json(viewModel));
}
internal static string[] GetAllFilenames <T>() where T : BusinessObject
{
var directory = DirectoryManager.GetFullDirectory <T>();
var files = Directory.GetFiles(directory);
return(files.Where(f => f.EndsWith(".xml")).Select(f => Path.GetFileNameWithoutExtension(f)).ToArray());
}
public virtual List <int> GetFolderPath(HttpContext context)
{
YZRequest request = new YZRequest(context);
int folderid = request.GetInt32("folderid");
List <int> path = new List <int>();
using (IYZDbProvider provider = YZDbProviderManager.DefaultProvider)
{
using (IDbConnection cn = provider.OpenConnection())
{
while (true)
{
Folder folder = DirectoryManager.GetFolderByID(provider, cn, folderid);
path.Insert(0, folder.FolderID);
folderid = folder.ParentID;
if (folderid == -1)
{
return(path);
}
}
}
}
}
public virtual object UpdateAttachment(HttpContext context)
{
YZRequest request = new YZRequest(context);
int id = request.GetInt32("id");
string fileid = request.GetString("fileid");
string replacewithfileid = request.GetString("replacewithfileid");
File file;
AttachmentInfo attachmentInfo;
using (IYZDbProvider provider = YZDbProviderManager.DefaultProvider)
{
using (IDbConnection cn = provider.OpenConnection())
{
file = DirectoryManager.GetFileByID(provider, cn, id);
attachmentInfo = AttachmentManager.UpdateAttachment(provider, cn, fileid, replacewithfileid);
}
}
using (BPMConnection bpmcn = new BPMConnection())
{
bpmcn.WebOpen();
return(this.Serialize(bpmcn, file, attachmentInfo));
}
}
public virtual object AddAttachmentToFolder(HttpContext context)
{
YZRequest request = new YZRequest(context);
int folderid = request.GetInt32("folderid");
string fileid = request.GetString("fileid");
string flag = request.GetString("flag", null);
AttachmentInfo attachmentInfo;
File file = new File();
using (IYZDbProvider provider = YZDbProviderManager.DefaultProvider)
{
using (IDbConnection cn = provider.OpenConnection())
{
attachmentInfo = AttachmentManager.GetAttachmentInfo(provider, cn, fileid);
file.FolderID = folderid;
file.FileID = fileid;
file.AddBy = YZAuthHelper.LoginUserAccount;
file.AddAt = DateTime.Now;
file.Flag = flag;
file.OrderIndex = DirectoryManager.GetFileNextOrderIndex(provider, cn, folderid);
DirectoryManager.Insert(provider, cn, file);
}
}
using (BPMConnection bpmcn = new BPMConnection())
{
bpmcn.WebOpen();
return(this.Serialize(bpmcn, file, attachmentInfo));
}
}
public async Task Save(IEnumerable <SimulationResult> results)
{
var resultsFile = DirectoryManager.GetLatestResultsFile();
var json = await Task.Factory.StartNew(() => JsonConvert.SerializeObject(results, Formatting.Indented));
await File.WriteAllTextAsync(resultsFile, json);
}
public void BeforeSave(IRepository repository, VideoCategory x)
{
if (string.IsNullOrWhiteSpace(x.Name) && x.State != State.Removed)
{
throw new Exception("Name cannot be empty");
}
if (x.State != State.Removed && repository.Get <VideoCategory>().Where(a => a.EntityId != x.EntityId && x.User_Id == x.User_Id && x.Name == a.Name).ExecuteAny())
{
throw new Exception("Name already exist");
}
if (x.EntityId.HasValue)
{
var videos = repository.Get <VideoData>().Where(a => a.Category_Id == x.EntityId).Skip(0).Take(5).Execute();
if (videos.Count() >= 1 && (videos.Count() <= 4 || string.IsNullOrWhiteSpace(x.Logo)))
{
var user = repository.Get <User>().Where(u => u.EntityId == x.User_Id).ExecuteFirstOrDefault();
if (!string.IsNullOrEmpty(x.Logo) && File.Exists(Path.Combine(Actions.ImageRootPath, x.Logo)))
{
File.Delete(Path.Combine(Actions.ImageRootPath, x.Logo));
}
var document = new DirectoryManager(Path.Combine(Actions.ImageRootPath, Actions.GenerateUserFolderName(user.Email))).Create();
var fName = $"{Guid.NewGuid().ToString("N")}.png";
var path = Path.Combine(document.DirectoryPath, fName);
var file = Actions.CombineImages(videos.Select(a => a.ThumpUrl).ToArray());
File.WriteAllBytes(path, file);
x.Logo = Path.Combine(Actions.GenerateUserFolderName(user.Email), fName);
}
}
}
private async Task <Orchestrator> GetOrchestrator(string targetApplicationProjectPath)
{
var directoryManager = new DirectoryManager();
var fileManager = new FileManager();
var deploymentManifestEngine = new DeploymentManifestEngine(directoryManager, fileManager);
var localUserSettingsEngine = new LocalUserSettingsEngine(fileManager, directoryManager);
var consoleInteractiveServiceImpl = new ConsoleInteractiveServiceImpl();
var consoleOrchestratorLogger = new ConsoleOrchestratorLogger(consoleInteractiveServiceImpl);
var commandLineWrapper = new CommandLineWrapper(consoleOrchestratorLogger);
var customRecipeLocator = new CustomRecipeLocator(deploymentManifestEngine, consoleOrchestratorLogger, commandLineWrapper, directoryManager);
var projectDefinition = await new ProjectDefinitionParser(fileManager, directoryManager).Parse(targetApplicationProjectPath);
var session = new OrchestratorSession(projectDefinition);
return(new Orchestrator(session,
consoleOrchestratorLogger,
new Mock <ICdkProjectHandler>().Object,
new Mock <ICDKManager>().Object,
new Mock <ICDKVersionDetector>().Object,
new TestToolAWSResourceQueryer(),
new Mock <IDeploymentBundleHandler>().Object,
localUserSettingsEngine,
new Mock <IDockerEngine>().Object,
customRecipeLocator,
new List <string> {
RecipeLocator.FindRecipeDefinitionsPath()
},
directoryManager));
}
private void CycleDirectories(DirectoryManager currentDirectory, Dictionary <string, Action <Blob> > extensionFunctions)
{
foreach (var dir in currentDirectory.Directories)
{
CycleDirectories(currentDirectory.FetchDirectory(dir), extensionFunctions);
}
foreach (var file in currentDirectory.Files.Where(x => extensionFunctions.Any(y => string.Equals(y.Key, x.Split('.').Last(), StringComparison.CurrentCultureIgnoreCase))))
{
var fileTexts = file.Split('.');
if (!fileTexts.Any())
{
continue;
}
foreach (var extension in extensionFunctions)
{
if (fileTexts.Any(x => string.Equals(x, extension.Key, StringComparison.CurrentCultureIgnoreCase)))
{
currentDirectory.ReadFile(file, extension.Value, true);
}
}
}
}
public static FileDownloadRequestList LoadFromDirectory(string strDirectory, string strTargetDirectory, Credentials objCredentials)
{
if ((strDirectory == null) || (strDirectory.Length == 0))
{
throw new ArgumentOutOfRangeException("strDirectory", "A valid non-null, non-empty string is required.");
}
if ((strTargetDirectory == null) || (strTargetDirectory.Length == 0))
{
throw new ArgumentOutOfRangeException("strTargetDirectory", "A valid non-null, non-empty string is required.");
}
if (DirectoryManager.Exists(strDirectory) == false)
{
throw new DirectoryNotFoundException(string.Format("The directory '{0}' does not exist.", strDirectory));
}
FileDownloadRequestList objFileDownloadRequests = new FileDownloadRequestList();
DirectoryInfo objDirectoryInfo = new DirectoryInfo(strDirectory);
FileInfo[] objFiles = objDirectoryInfo.GetFiles("*.*", SearchOption.AllDirectories);
foreach (FileInfo objFile in objFiles)
{
string strTargetFilePath = objFile.FullName.Replace(strDirectory, strTargetDirectory);
FileDownloadRequest objFileDownloadRequest = new FileDownloadRequest(objFile.FullName, strTargetFilePath, objCredentials);
objFileDownloadRequests.Add(objFileDownloadRequest);
}
return(objFileDownloadRequests);
}
public static string CreateTrailFileName(string semeterfileDirectory)
{
string[] splittedDirectory = semeterfileDirectory.Split('.');
int tracker = splittedDirectory.Count() - 1;
semeterfileDirectory = null;
for (int i = 0; i <= tracker; i++)
{
if (i != tracker)
{
if (semeterfileDirectory == null)
{
semeterfileDirectory = splittedDirectory[i];
}
else
{
semeterfileDirectory = semeterfileDirectory + "." + splittedDirectory[i];
}
}
else
{
semeterfileDirectory = semeterfileDirectory + "T." + splittedDirectory[i];
}
}
//semeterfileDirectory = splittedDirectory[0]+splittedDirectory[1] + "T.txt";
DirectoryManager.CreateFile(semeterfileDirectory);
return(semeterfileDirectory);
}
public async void DirectoryGetPermissions()
{
var user1 = await UserManager.GenerateUser();
var subDirectoryId = IdGenerator.NewId(IdType.Directory);
Assert.True(await DirectoryManager.InsertDirectory(
user1.UserId,
user1.RootDirectoryId,
"Dir1",
subDirectoryId));
var directoryPermissions = await DirectoryManager.GetPermissions(
user1.UserId,
user1.UserId,
new[] { user1.RootDirectoryId, subDirectoryId });
var rootDirPermissions = directoryPermissions.First(x => x.ObjectId == user1.RootDirectoryId);
var subDirPermissions = directoryPermissions.First(x => x.ObjectId == subDirectoryId);
Assert.Equal(rootDirPermissions.Permission, subDirPermissions.Permission);
Assert.Equal(rootDirPermissions.Permission,
(Permission.ReadWrite |
Permission.Read |
Permission.ReadPermissions |
Permission.ReadWritePermissions)
);
}
public HttpResponseMessage SubmitResult([FromBody] string testResJSON)
{
DirectoryManager dirman = new DirectoryManager();
TestManager testman = new TestManager(dirman);
TestResultManager testResMan = new TestResultManager(dirman);
try
{
ResultToSubmit resultToSubmit = JsonConvert.DeserializeObject <ResultToSubmit>(testResJSON);
testman.SubmitTestResults(resultToSubmit.authorName,
"otherResults", resultToSubmit.testTitle,
string.Concat(resultToSubmit.correctAnswerCount,
"/", resultToSubmit.questionCount), resultToSubmit.guessingUserName);
testman.SubmitTestResults(resultToSubmit.guessingUserName,
"personalResults", resultToSubmit.testTitle,
string.Concat(resultToSubmit.correctAnswerCount,
"/", resultToSubmit.questionCount), resultToSubmit.authorName);
return(Request.CreateResponse(HttpStatusCode.OK));
}
catch (Exception)
{
return(Request.CreateResponse(HttpStatusCode.Forbidden));
}
}
public void GetRelativePath(string relativeTo, string path, string expectedPath)
{
var directoryManager = new DirectoryManager();
var relativePath = directoryManager.GetRelativePath(relativeTo, path);
Assert.Equal(expectedPath, relativePath);
}
public async void FileMove()
{
var user1 = await UserManager.GenerateUser();
var subDirectoryId = IdGenerator.NewId(IdType.Directory);
Assert.True(await DirectoryManager.InsertDirectory(
user1.UserId,
user1.RootDirectoryId,
"Dir1",
subDirectoryId));
var fileId = IdGenerator.NewId(IdType.File);
var revisionId = IdGenerator.NewId(IdType.FileBlob);
var keys = new Dictionary <string, string>()
{
{ user1.UserId, "EncryptedKey" }
};
var quickNumberFile1 = await FileManager.InsertFile(
user1.UserId,
user1.RootDirectoryId,
fileId,
revisionId,
"File1",
2000000,
keys,
DocumentLanguage.English,
ExtensionType.Pdf
);
// Check if root directory contains the file
var directoryMetadata = await DirectoryManager.GetDirectoryMetadata(user1.UserId, user1.RootDirectoryId, null);
Assert.Single(directoryMetadata.FileChilds);
Assert.Equal(fileId, directoryMetadata.FileChilds.First().ObjectId);
// Check if path is correct
var fileMetadata = await FileManager.GetFileMetadata(user1.UserId, fileId, revisionId);
Assert.Equal($"/{user1.RootDirectoryId}/{fileId}", fileMetadata.Path);
// Move file to sub directory
Assert.True(await FileManager.Move(user1.UserId, fileId, subDirectoryId));
directoryMetadata = await DirectoryManager.GetDirectoryMetadata(user1.UserId, subDirectoryId, null);
fileMetadata = await FileManager.GetFileMetadata(user1.UserId, fileId, revisionId);
Assert.Single(directoryMetadata.FileChilds);
Assert.Equal(fileId, directoryMetadata.FileChilds.First().ObjectId);
Assert.Single(fileMetadata.Permissions);
Assert.Single(directoryMetadata.Permissions);
Assert.Equal(directoryMetadata.Permissions.First().Value, fileMetadata.Permissions.First().Value);
Assert.Equal(
Permission.ReadWrite | Permission.Read | Permission.ReadPermissions | Permission.ReadWritePermissions,
fileMetadata.Permissions.First().Value);
Assert.Equal($"/{user1.RootDirectoryId}/{subDirectoryId}/{fileId}", fileMetadata.Path);
}
/// <summary>
///
/// </summary>
/// <param name="author"></param>
/// <param name="mod">Must match your mod directory name</param>
/// <param name="modVersion"></param>
public FoxCore(string author, string mod, string modVersion = null)
{
_author = author;
_mod = mod;
_version = modVersion;
ExceptionManager = new ExceptionManager(author, mod, modVersion);
WorldManager = new WorldManager();
SaveDirectory = new DirectoryManager(author, mod);
if (!modVersion.IsNullOrEmpty())
{
SaveDirectory = SaveDirectory.FetchDirectoryNoParent(modVersion);
}
ModDirectory = new DirectoryManager(mod)
{
ContentFolder = true
};
ModsDirectory = new DirectoryManager {
ContentFolder = true
}.FetchDirectoryNoParent("content");
ModsDirectory = ModsDirectory.FetchDirectoryNoParent("mods");
ConfigDirectory = new DirectoryManager().FetchDirectoryNoParent("modConfigs").FetchDirectoryNoParent(mod);
if (!modVersion.IsNullOrEmpty())
{
ConfigDirectory = ConfigDirectory.FetchDirectoryNoParent(modVersion);
}
ContentDirectory = new DirectoryManager {
ContentFolder = true
}.FetchDirectoryNoParent("content");
_patchControllerId = $"{_author}.{_mod}";
}
public async Task ShouldDeleteFile()
{
//Arrange
await using var context = GetDbContext(true);
var mockResolver = new Mock <IUserResolver>();
var mockFileStorage = new Mock <IFileStorage>();
var authManager = new AuthorizationManager(context, Mapper, mockResolver.Object);
var fileManager = new Implementations.FileManager(context, Mapper, mockFileStorage.Object);
var directoryMnager = new DirectoryManager(context, Mapper, fileManager);
var repoManager = new RepositoryManager(context, Mapper, directoryMnager, authManager);
var filePath = Guid.NewGuid().ToString();
mockFileStorage.Setup(x => x.UploadAsync(It.IsAny <string>())).Returns(Task.FromResult(filePath));
mockFileStorage.Setup(x => x.DeleteAsync(It.IsAny <string>())).Returns(Task.CompletedTask);
var user = await SeedUserAsync(context);
mockResolver.Setup(x => x.GetUserAsync()).Returns(Task.FromResult(Mapper.Map <UserDTO>(user)));
var repoRoot = await repoManager.CreateRepositoryAsync(user.Id, "Test Repo");
var fileName = "FileName.har";
var file = await fileManager.UploadFileAsync(repoRoot.Id, fileName, "{}");
//Act
await fileManager.DeleteFileAsync(file.Id);
var fileFromDB = await context.Set <File>()
.FindAsync(file.Id);
//Assert
Assert.Null(fileFromDB);
}
private void VariantLoader_Shown(object sender, EventArgs e)
{
_colors = new Dictionary <string, Dictionary <Color, Color> >();
var modDir = new DirectoryManager().FetchDirectory("content").FetchDirectory("mods");
prgrssMods.Maximum = modDir.Directories.Count;
foreach (var mod in modDir.Directories)
{
prgrssMods.Value = modDir.Directories.ToList().IndexOf(mod) + 1;
lblMod.Text = $@"{mod} ({prgrssMods.Value} of {modDir.Directories.Count})";
_colors.Clear();
Application.DoEvents();
lblTileItem.Text = @"Fetching Palettes";
lblPalette.Text = @"Fetching Palettes";
prgrssTileItems.Style = ProgressBarStyle.Marquee;
prgrssPalettes.Style = ProgressBarStyle.Marquee;
Application.DoEvents();
CycleGetPalettes(modDir.FetchDirectory(mod));
prgrssTileItems.Style = ProgressBarStyle.Blocks;
prgrssPalettes.Style = ProgressBarStyle.Blocks;
Application.DoEvents();
CycleGenerate(modDir.FetchDirectory(mod));
}
Close();
}
public async Task ShouldGetUserRepositories()
{
//Arrange
await using var context = GetDbContext(true);
var directoryMnager = new DirectoryManager(context, Mapper, null);
var repoManager = new RepositoryManager(context, Mapper, directoryMnager, null);
var user = await SeedUserAsync(context);
var repoNames = new List <string>()
{
"Test Repo 1", "Test Repo 2", "Test Repo 3"
};
await repoManager.CreateRepositoryAsync(user.Id, repoNames[0]);
await repoManager.CreateRepositoryAsync(user.Id, repoNames[1]);
await repoManager.CreateRepositoryAsync(user.Id, repoNames[2]);
//Act
var userRepos = await repoManager.GetUserRepositoriesAsync(user.Id);
//Assert
Assert.Equal(3, userRepos.Count);
Assert.Contains(userRepos[0].Name, repoNames);
Assert.Contains(userRepos[1].Name, repoNames);
Assert.Contains(userRepos[2].Name, repoNames);
}
// POST: api/Directory
public dynamic Post([FromBody] DirAction action)
{
action.SetType();
switch (action.Type)
{
case ActionType.GetDrives:
return(DirectoryManager.GetDrives());
case ActionType.GetItems:
return(DirectoryManager.GetDirItems(action.Path));
case ActionType.CountFiles:
{
string[] args = action.Path.Split('|');
FileCounter counter = new FileCounter(args[0], args[1]);
string start = DirectoryManager.GetNextFolder(counter.Path, counter.LastPath);
while (!DirectoryManager.CountFiles(start, ref counter))
{
start = DirectoryManager.GetNextFolder(counter.Path, counter.LastPath);
}
counter.Done = (start.Length == 0);
return(counter);
}
}
return(null);
}
public AccountController(
IHostingEnvironment environment,
IIdentityServerInteractionService interaction,
UserManager userManager,
SignInManager signInManager,
MessagingService messagingService,
ILoggerFactory loggerFactory,
ICypher cypher,
IHttpContextAccessor httpContextAccessor,
AegisTenantResolver aegisTenantResolver,
DirectoryManager directoryManager
)
{
_logger = loggerFactory.CreateLogger <AccountController>();
_environment = environment;
_interaction = interaction;
_userManager = userManager;
_signInManager = signInManager;
_messaging = messagingService;
_cypher = cypher;
_httpContextAccessor = httpContextAccessor;
_aegisTenantResolver = aegisTenantResolver;
_directoryManager = directoryManager;
}
public async void DirectoryInsert_Rename()
{
var user1 = await UserManager.GenerateUser();
var subDirectoryId = IdGenerator.NewId(IdType.Directory);
Assert.True(await DirectoryManager.InsertDirectory(
user1.UserId,
user1.RootDirectoryId,
"Dir1",
subDirectoryId
));
// Rename directory
Assert.True(await DirectoryManager.Rename(user1.UserId, subDirectoryId, "Renamed dir!"));
// Try to insert new directory with old name
Assert.True(await DirectoryManager.InsertDirectory(
user1.UserId,
user1.RootDirectoryId,
"Dir1",
IdGenerator.NewId(IdType.Directory)));
// Ensure metadata is updated
var metadata = await DirectoryManager.GetDirectoryMetadata(user1.UserId, subDirectoryId, null);
Assert.Equal("Renamed dir!", metadata.ObjectName);
}
public virtual object GetFolderDocuments(HttpContext context)
{
YZRequest request = new YZRequest(context);
int folderid = request.GetInt32("folderid");
int top = request.GetInt32("top", -1);
string order = request.GetString("order", null);
using (BPMConnection bpmcn = new BPMConnection())
{
bpmcn.WebOpen();
using (IYZDbProvider provider = YZDbProviderManager.DefaultProvider)
{
using (IDbConnection cn = provider.OpenConnection())
{
List <object> rv = new List <object>();
FileCollection files = DirectoryManager.GetFiles(provider, cn, folderid, null, order, top);
foreach (File file in files)
{
AttachmentInfo attachmentInfo = AttachmentManager.TryGetAttachmentInfo(provider, cn, file.FileID);
if (attachmentInfo == null)
{
continue;
}
rv.Add(this.Serialize(bpmcn, file, attachmentInfo));
}
return(rv);
}
}
}
}
public AppService()
{
DirectoryManager = new DirectoryManager();
//DirectoryManager.ClearDirectory(DirectoryManager.TempDirectory);
LoggingHelper = new LoggingHelper();
LoggList = new ObservableCollection <LoggViewModel>();
}
public async Task ShouldCreateDirectory()
{
//Arrange
await using var context = GetDbContext(true);
var mockResolver = new Mock <IUserResolver>();
var authManager = new AuthorizationManager(context, Mapper, mockResolver.Object);
var directoryMnager = new DirectoryManager(context, Mapper, null);
var repoManager = new RepositoryManager(context, Mapper, directoryMnager, authManager);
var user = await SeedUserAsync(context);
mockResolver.Setup(x => x.GetUserAsync()).Returns(Task.FromResult(Mapper.Map <UserDTO>(user)));
var repoRoot = await repoManager.CreateRepositoryAsync(user.Id, "Test Repo");
//Act
var dirName = "Test Directory";
var directory = await directoryMnager.CreateDirectoryAsync(dirName, repoRoot.Id);
var parent = await context.Set <Directory>()
.Include(x => x.SubDirectories)
.SingleOrDefaultAsync(x => x.Id == repoRoot.Id);
//Assert
Assert.NotNull(directory);
Assert.True(directory.Id > 0);
Assert.Equal(dirName, directory.Name);
Assert.Single(parent.SubDirectories);
Assert.Equal(parent.SubDirectories.First().Id, directory.Id);
}
public void SubmitButtonExecute(object parameter)
{
bool doesStudentExist = false;
if (Directory.Exists(DirectoryManager.AccountsDirectory) && (string)parameter == "")
{
Student tempStudent = DirectoryManager.ReadStudentobject(FirstName, LastName, Email);
if (tempStudent != null)
{
doesStudentExist = true;
verified = false;
ErrorEmail = "This Email Already Exist";
}
else
{
ErrorEmail = string.Empty;
}
}
if (this.Error == null && doesStudentExist == false && (string)parameter == "")
{
//just trying to invoke the setter in the Gender property to carry out the logic that is built into it.
this.Gender = "";
Student newStudent = new Student(FirstName, LastName, Gender, BirthDate, Program, CurrentLevel, CurrentSemester, Institution, Email);
DirectoryManager.CreatePersonalDirectory(ref newStudent);
verified = true;
CurrentStudent = Student.Login(FirstName, Email);
}
}
private void UpdateServiceReference(Project project, List <MksProjectFile> mksProjectFiles, ProjectItem[] allReferences, string[] serviceReferences)
{
var nameSpaceToServiceRefernceDictionary =
serviceReferences.ToDictionary(c => c.SplitWithStrings("=")[0], d => d.SplitWithStrings("=")[1]);
//get any item that is a service reference from the original project
var serviceRefItems = project.Items.Where(d => d.EvaluatedInclude.StartsWith("Service References"));
//group them by their labels
var serviceRefDictionary = serviceRefItems.GroupBy(c => c.EvaluatedInclude.SplitWithStrings("\\")[1]);
var serviceNameSpaces = nameSpaceToServiceRefernceDictionary.Keys.ToList();
foreach (var mksProjectFile in mksProjectFiles)
{
var hasServiceRef = mksProjectFile.ProjectItems.SelectMany(d => d.References).Intersect(serviceNameSpaces).ToArray();
if (hasServiceRef.Length > 0)
{
var doc = XDocument.Parse(mksProjectFile.XML).Root;
var itemGroupName = XName.Get("ItemGroup", doc.GetDefaultNamespace().NamespaceName);
var noneName = XName.Get("None", doc.GetDefaultNamespace().NamespaceName);
var endInsertion = doc.Descendants().FirstOrDefault(c => c.Name.LocalName == "EndInsertion");
foreach (var refs in hasServiceRef)
{
var originalDirectoryPath = Path.Combine(project.DirectoryPath, $"Service References\\{nameSpaceToServiceRefernceDictionary[refs]}\\");
var newServiceDir = Path.Combine(mksProjectFile.AbsoluteTargetDir,
$"Service References\\{nameSpaceToServiceRefernceDictionary[refs]}\\");
//1 make the directory that will house the service refs
DirectoryManager.Copy(originalDirectoryPath, newServiceDir);
}
//2 mark up the xml
if (doc.Descendants("WCFMetadata").Count() == 0)
{
endInsertion.AddBeforeSelf(new XElement(itemGroupName,
new XElement(XName.Get("WCFMetadata", doc.GetDefaultNamespace().NamespaceName),
new XAttribute("Include", @"Service References\"))));
}
endInsertion.AddBeforeSelf(new XElement(itemGroupName,
hasServiceRef.Select(c =>
new XElement(XName.Get("WCFMetadataStorage", doc.GetDefaultNamespace().NamespaceName),
new XAttribute("Include", $"Service Reference\\{nameSpaceToServiceRefernceDictionary[c]}\\")))));
var element = new XElement(itemGroupName
, serviceRefItems.Where(d => d.EvaluatedInclude.ContainsSearch(hasServiceRef.Select(e => nameSpaceToServiceRefernceDictionary[e])) &&
d.ItemType == "None")
.Select(c =>
new XElement(noneName
, new XAttribute("Include", c.EvaluatedInclude))));
endInsertion.AddBeforeSelf(element);
mksProjectFile.XML = doc.ToString();
}
}
}
public MainWindow()
{
Thread.CurrentThread.CurrentCulture = new System.Globalization.CultureInfo("fa-IR");
InitializeComponent();
#region setting and init
if (!Properties.Settings.Default.HomePageVisibility)
{
btnHome.Visibility = Visibility.Collapsed;
}
if (!Properties.Settings.Default.CreditDeterminerVisibility)
{
btnCreditDeterminer.Visibility = Visibility.Collapsed;
}
if (!Properties.Settings.Default.AdaptTableVisibility)
{
btnAdaptationTableCourses.Visibility = Visibility.Collapsed;
}
if (!Properties.Settings.Default.StudHistoryVisibility)
{
btnStudentHistory.Visibility = Visibility.Collapsed;
}
if (!Properties.Settings.Default.OfferedCourseManagerVisibility)
{
btnOfferedCoursesManager.Visibility = Visibility.Collapsed;
}
if (!Properties.Settings.Default.ReductionStep2SettingVisibility)
{
btnReductionStep2Settings.Visibility = Visibility.Collapsed;
}
if (Properties.Settings.Default.StartPage == 0)
{
Button_Click(btnHome, null);
}
else if (Properties.Settings.Default.StartPage == 1)
{
Button_Click(btnStudentHistory, null);
}
else if (Properties.Settings.Default.StartPage == 2)
{
Button_Click(btnOfferedCoursesManager, null);
}
else if (Properties.Settings.Default.StartPage == 3)
{
Button_Click(btnReductionStep2Settings, null);
}
else if (Properties.Settings.Default.StartPage == 4)
{
Button_Click(btnReductionStep2, null);
}
else if (Properties.Settings.Default.StartPage == 5)
{
Button_Click(btnWeeklyProgram, null);
}
DirectoryManager.TryCreateApplicationDirectoriesIfNotExists();
#endregion
}
private void WriteReportHtml(DirectoryManager dirManager, StreamWriter sw, Report report, string suiteName)
{
CreateReportHeadingHtml(sw, report, suiteName);
sw.Write(_htmlSupport.GetTagStart("table"));
WriteHtmlRow(sw, "Diff Image: ", CreateImageHtmlWithLinkToSideBySide(report.Test, dirManager));
sw.Write(_htmlSupport.GetTagEnd("table"));
}
private Response GetUserAvatar(string username)
{
const string ContentType = "image/jpg";
var avatarPath = DirectoryManager.GetLocalPath() + $"Avatars\\{username}\\{username}.jpg";
var avatar = avatarManager.GetAvatar(avatarPath);
return(avatar == null ? HttpStatusCode.NotFound : Response.FromStream(avatar, ContentType));
}
void Directory_OnEventInfo(DirectoryManager.EventInfo matchedEvent)
{
float x,y;
Helpers.GlobalPosToRegionHandle((float)matchedEvent.GlobalPos.X, (float)matchedEvent.GlobalPos.Y, out x, out y);
StringBuilder sb = new StringBuilder();
sb.AppendFormat(" Name: {0} ({1})" + System.Environment.NewLine, matchedEvent.Name, matchedEvent.ID);
sb.AppendFormat(" Location: {0}/{1}/{2}" + System.Environment.NewLine, matchedEvent.SimName, x, y);
sb.AppendFormat(" Date: {0}" + System.Environment.NewLine, matchedEvent.Date);
sb.AppendFormat("Description: {0}" + System.Environment.NewLine, matchedEvent.Desc);
Console.WriteLine(sb.ToString());
}
public string GetNewDirName()
{
var newDirManager = new DirectoryManager();
return newDirManager.GetNewDirectoryName ();
}
public Dictionary<string, DirectoryHolder> GetAllFolders()
{
foreach (var folder in directoryHolders)
{
Destroy(folder.Value.Button);
}
directoryHolders.Clear ();
var newDirManager = new DirectoryManager();
newDirManager.SetDictionary = directoryHolders;
return newDirManager.GetAllDirectories (FolderButton);
}
