internal bool IsTaskReadyToExecute(TaskItem task) { if (task == null) return false; var req = task.SystemData as TaskRequest; if (req == null) return true; return (req.LastAttempt + AttemptInterval <= DateTime.UtcNow); }
public void refresh(TaskItem item) { templateID = item.templateID; type = item.type; TaskName.text = item.name; TaskDes.text = item.decribe; if(type == (int)GlobalDef.TaskType.T_ONECE) { Title.spriteName = "08"; } else if(type == (int)GlobalDef.TaskType.T_EVERTYDAY) { Title.spriteName = "07"; } // if(item.isFinish()) // { // Finish.gameObject.SetActive(true); // } // else // { // Finish.gameObject.SetActive(false); // } }
internal TimeSpan NeedWaitTask(TaskItem task) { TimeSpan timespan = TimeSpan.Zero; if (task == null) return timespan; var req = task.SystemData as TaskRequest; if (req == null) return timespan; return (req.LastAttempt + AttemptInterval) - DateTime.UtcNow; }
public void Replace (TaskItem inner) { if (inner != Inner) { DisposeInner(); Inner = inner; } }
public void SaveAndReload () { Inner.Save(); var entryId = Inner.EntryID; DisposeInner(); Thread.MemoryBarrier(); Inner = _load (entryId); }
/// <summary> /// 添加任务 /// </summary> public void addTask(TaskItem task) { if(taskDict.ContainsKey(task.templateID)) { Debug.LogError("already has this task!"); return; } taskDict.Add(task.templateID, task); }
private void createTaskButton_Click(object sender, RoutedEventArgs e) { TaskItem newtask = new TaskItem() { AlertTime = new TimeSpan(13, 0, 0).ToString(), DueTime = new TimeSpan(13, 0, 0).ToString(), EscalationLevel1Time = new TimeSpan(13, 0, 0).ToString(), AssetCategoryID = 116, BusinessAreaID = 30, BypassManagerApproval = false, ChecklistID = 2, Comments = "No comments", Description = "Task2_Description", DocumentURL = "", FrequencyID = 7, FunctionalID = null, KeyControl = false, LocationID = 48, ManagerSelfApproval = false, RandomFrequencyID = null, SpecificFrequencyID = null, TaskName = "Task2", HolidayCalendar = true }; List<User> taskassignees = new List<User>() { new User() { BRID = "E20037236", UserLoginID = "ghoshnil" } }; List<User> taskmanagers = new List<User>() { new User() { BRID = "G47969783", UserLoginID = "mistryna" } }; newtask.Assignees = taskassignees; newtask.Managers = taskmanagers; var request = new RestRequest("CreateTask", RestSharp.Method.POST) { RequestFormat = DataFormat.Json }.AddBody(newtask); checcklistadminclient.ExecuteAsync(request, (response) => { if (response.ResponseStatus == ResponseStatus.Error) { int i = 1; } else { var result = JsonConvert.DeserializeObject<List<TaskItem>>(response.Content); int i = 1; } }); }
public EditTaskItem(ICollectionView view, TaskItem taskItem) { InitializeComponent(); this.DataContext = taskItem; _view = view; _taskItem = taskItem; this.Loaded += OnEditTaskItemLoaded; this.Closed += OnClosed; }
internal virtual void ExecuteTask(TaskItem task) { if (task == null) return; try { task.Task(task.UserData); } catch { } }
public DesignDetailsViewModel() : base(null, null) { TaskItem = new TaskItem() { Title = "Sample Task", Description = "Description of the Sample Task", CreatedDate = DateTime.Now, DueDate = DateTime.Now.AddDays(1), Priority = Priority.Medium }; }
public void AddDataItem(TaskItem newDataItem) { // Add a to-do item to the data context. dataDB.Items.InsertOnSubmit(newDataItem); // Save changes to the database. dataDB.SubmitChanges(); // Add a to-do item to the "all" observable collection. AllDataItems.Add(newDataItem); }
private void SaveItemButton_Click(object sender, RoutedEventArgs e) { if (!String.IsNullOrEmpty(ItemName.Text) && !String.IsNullOrEmpty(ItemDescription.Text) && comboBox.SelectedIndex > -1) { TaskItem saveItem = new TaskItem(ItemName.Text, ItemDescription.Text); saveItem.startTime = ItemStartDate.Date.DateTime + ItemStartTime.Time; saveItem.endTime = ItemEndDate.Date.DateTime + ItemEndTime.Time; App.tasksManager.sections[comboBox.SelectedIndex].AddItem(saveItem); App.tasksManager.saveToFile(); saveItem = null; this.Frame.Navigate(typeof(TaskItemView), App.tasksManager.sections[comboBox.SelectedIndex]); } }
public void Description() { PropertiesChanged = new List<String>(); var description = Guid.NewGuid().ToString(); var taskItem = new TaskItem(); taskItem.PropertyChanged += OnPropertyChanged; taskItem.Description = description; taskItem.PropertyChanged -= OnPropertyChanged; Assert.AreEqual(description, taskItem.Description, "Description"); Assert.IsTrue(PropertiesChanged.Contains("Description"), "Description Property Changed"); }
public void DueDate() { PropertiesChanged = new List<String>(); var dueDate = DateTime.Now; var taskItem = new TaskItem(); taskItem.PropertyChanged += OnPropertyChanged; taskItem.DueDate = dueDate; taskItem.PropertyChanged -= OnPropertyChanged; Assert.AreEqual(dueDate, taskItem.DueDate, "DueDate"); Assert.IsTrue(PropertiesChanged.Contains("DueDate"), "DueDate Property Changed"); }
public void addTempData() { for(int i = 0; i < 5; i++) { TaskItem item = new TaskItem(); item.templateID = 800001 + i; everyDayTask.addTask(item); TaskItem item1 = new TaskItem(); item1.templateID = 800001 + i; mainThreadTask.addTask(item1); } }
public void SetUp() { _TaskTreeView = new NuGenTaskTreeView(); _InitialCount = _TaskTreeView.Nodes.Count; _EventSink = new TaskTreeViewEventSink(_TaskTreeView); _ServiceProvider = new NuGenTaskServiceProvider(); _XmlDoc = new XmlDocument(); _TaskItemDescription = "Description"; _TaskItemMock = new DynamicMock(typeof(TaskItem)); _TaskItemMock.SetValue("Description", _TaskItemDescription); _TaskItem = (TaskItem)_TaskItemMock.Object; Assert.IsFalse(_TaskTreeView.LabelEdit); }
public void DeleteTask() { var taskItem = new TaskItem(); var expectedTasks = new ObservableCollection<TaskItem>(); expectedTasks.Add(taskItem); TaskRepository.Tasks = expectedTasks; var args = new ExecuteEventArgs() { MethodParameter = taskItem }; ViewModel.DeleteTask(null, args); var actualTasks = ViewModel.Tasks; Assert.IsFalse(actualTasks.Contains(taskItem)); }
// Use this for initialization protected void Start() { library = GameObject.FindObjectOfType<Library>(); taskValue = library.taskStrings.GetTaskValue(this.GetType().Name); item = library.pauseMenu.AddTask(this); item.SetDescription(GetDescription()); item.SetReward(reward + ""); if (PreferencesSaver.TaskIsComplete(1, this.GetType().Name)) { SetComplete(); item.SetDone(); } }
public static void CallsExecuteAssemblyOnceForEachAssembly() { var visitor = new XmlTestExecutionVisitor(null, null); visitor.Finished.Set(); var assm1 = new TaskItem(@"C:\Full\Path\1"); var assm2 = new TaskItem(@"C:\Full\Path\2", new Dictionary<string, string> { { "ConfigFile", @"C:\Config\File" } }); var xunit = new Testable_xunit { CreateVisitor_Result = visitor }; xunit.Assemblies = new ITaskItem[] { assm1, assm2 }; xunit.Execute(); Assert.Collection(xunit.ExecuteAssembly_Calls, call => Assert.Equal(@"C:\Full\Path\1, (null)", call), call => Assert.Equal(@"C:\Full\Path\2, C:\Config\File", call) ); }
public void TestCtor2 () { string itemName = "itemName"; string itemSpec = "a;b;c"; // result of Utilities.Escape (itemSpec) string escapedInclude = "a%3bb%3bc"; ITaskItem taskItem = new TaskItem (itemSpec); item = new BuildItem (itemName, taskItem); Assert.AreEqual (itemSpec, item.FinalItemSpec, "A1"); Assert.AreEqual (escapedInclude, item.Include, "A2"); Assert.AreEqual (String.Empty, item.Exclude, "A3"); Assert.AreEqual (String.Empty, item.Condition, "A4"); Assert.AreEqual (false, item.IsImported, "A5"); Assert.AreEqual (itemName, item.Name, "A6"); }
internal override void ExecuteTask(TaskItem task) { var request = task.SystemData as TaskRequest; if (request == null) throw new ApplicationException("invalid task"); request.CurrentAttempt++; request.LastAttempt = DateTime.UtcNow; bool done = false; try { done = task.Task(task.UserData); } catch { } if (!done) { if (request.CurrentAttempt < AttemptCount) EnqueueTaskInternal(task); } }
public void onAddTask(SocketModel module) { TaskMessage.MsgAddNewTaskRep msg = MsgSerializer.Deserialize<TaskMessage.MsgAddNewTaskRep>(module); int templateID = msg.task.taskId; int type = StaticMission.Instance().getInt(templateID, "type"); TaskItem item = new TaskItem(); item.parseData(msg.task); if(type == (int)GlobalDef.TaskType.T_ONECE) { MonoInstancePool.getInstance<TaskManager>().getMainthreadTask().addTask(item); MonoInstancePool.getInstance<TaskManager>().getMainthreadTask().isDirty = true; } else if(type == (int)GlobalDef.TaskType.T_EVERTYDAY) { MonoInstancePool.getInstance<TaskManager>().getEveryDayTask().addTask(item); MonoInstancePool.getInstance<TaskManager>().getEveryDayTask().isDirty = true; } }
public IEnumerable<Project> Interpret(string dslText) { List<Project> projects = new List<Project>(); var grammar = new ProjectsGrammar(); var interpriter = new ScriptInterpreter(grammar); interpriter.Evaluate(dslText); if (interpriter.Status != InterpreterStatus.Ready) { throw new InvalidOperationException("Your syntax errored!?"); } var program = interpriter.ParsedScript.Root.AstNode as StatementListNode; foreach (var node in program.ChildNodes) { if (node.Term.Name == "Project") { var projectName = (LiteralValueNode) node.ChildNodes[0]; var project = new Project(projectName.Value.ToString().Trim()); projects.Add(project); var notes = (StatementListNode) node.ChildNodes[1]; foreach(var note in notes.ChildNodes) { project.AddNote(((LiteralValueNode) note).Value.ToString().Trim()); } var tasks = (StatementListNode)node.ChildNodes[2]; foreach (var child in tasks.ChildNodes) { var taskName = (LiteralValueNode)child.ChildNodes[0]; var task = new TaskItem(taskName.Value.ToString()); projects.Last().AddTask(task); var taskNotes = (StatementListNode)child.ChildNodes[1]; foreach (var note in taskNotes.ChildNodes) { task.AddNote(((LiteralValueNode)note).Value.ToString().Trim()); } } } } return projects; }
public void onGetTaskList(SocketModel module) { TaskMessage.MsgGetTaskListRep msg = MsgSerializer.Deserialize<TaskMessage.MsgGetTaskListRep>(module); for(int i = 0; i < msg.mainTaskList.Count; i++) { TaskItem item = new TaskItem(); TaskMessage.Task data = msg.mainTaskList[i]; item.parseData(data); // Debug.Log("---------------id: " + msg.mainTaskList[i].param1_value + " " + msg.mainTaskList[i].param2_value + " " + item.param1_value + " " + item.param2_value); MonoInstancePool.getInstance<TaskManager>().getMainthreadTask().addTask(item); MonoInstancePool.getInstance<TaskManager>().getMainthreadTask().isDirty = true; } for(int i = 0; i < msg.dailyTaskList.Count; i++) { TaskItem item = new TaskItem(); TaskMessage.Task data = msg.mainTaskList[i]; item.parseData(data); MonoInstancePool.getInstance<TaskManager>().getEveryDayTask().addTask(item); MonoInstancePool.getInstance<TaskManager>().getEveryDayTask().isDirty = true; } }
public override bool Execute() { var prefixes = BundleResource.SplitResourcePrefixes(ResourcePrefix); var bundleResources = new List <ITaskItem> (); if (BundleResources != null) { foreach (var item in BundleResources) { var logicalName = BundleResource.GetLogicalName(ProjectDir, prefixes, item, !string.IsNullOrEmpty(SessionId)); // We need a physical path here, ignore the Link element var path = item.GetMetadata("FullPath"); string illegal; if (!File.Exists(path)) { Log.LogError(MSBStrings.E0099, logicalName, path); continue; } if (logicalName.StartsWith(".." + Path.DirectorySeparatorChar, StringComparison.Ordinal)) { Log.LogError(null, null, null, item.ItemSpec, 0, 0, 0, 0, MSBStrings.E0100, logicalName); continue; } if (logicalName == "Info.plist") { Log.LogWarning(null, null, null, item.ItemSpec, 0, 0, 0, 0, MSBStrings.E0101); continue; } if (BundleResource.IsIllegalName(logicalName, out illegal)) { Log.LogError(null, null, null, item.ItemSpec, 0, 0, 0, 0, MSBStrings.E0102, illegal); continue; } var bundleResource = new TaskItem(item); bundleResource.SetMetadata("LogicalName", logicalName); bool optimize = false; if (CanOptimize(item.ItemSpec)) { var metadata = item.GetMetadata("Optimize"); // fall back to old metadata name if (string.IsNullOrEmpty(metadata)) { metadata = item.GetMetadata("OptimizeImage"); } if (string.IsNullOrEmpty(metadata) || !bool.TryParse(metadata, out optimize)) { switch (Path.GetExtension(item.ItemSpec).ToLowerInvariant()) { case ".plist": case ".strings": optimize = OptimizePropertyLists; break; case ".png": optimize = OptimizePNGs; break; } } } bundleResource.SetMetadata("Optimize", optimize.ToString()); bundleResources.Add(bundleResource); } } BundleResourcesWithLogicalNames = bundleResources.ToArray(); return(!Log.HasLoggedErrors); }
// Extracts library project contents under e.g. obj/Debug/[__library_projects__/*.jar | res/*/*] // Extracts library project contents under e.g. obj/Debug/[lp/*.jar | res/*/*] void Extract( DirectoryAssemblyResolver res, IDictionary <string, ITaskItem> jars, ICollection <ITaskItem> resolvedResourceDirectories, ICollection <ITaskItem> resolvedAssetDirectories, ICollection <ITaskItem> resolvedEnvironments) { // lets "upgrade" the old directory. string oldPath = Path.GetFullPath(Path.Combine(OutputImportDirectory, "..", "__library_projects__")); if (!OutputImportDirectory.Contains("__library_projects__") && Directory.Exists(oldPath)) { MonoAndroidHelper.SetDirectoryWriteable(Path.Combine(oldPath, "..")); Directory.Delete(oldPath, recursive: true); } var outdir = Path.GetFullPath(OutputImportDirectory); Directory.CreateDirectory(outdir); foreach (var assembly in Assemblies) { res.Load(assembly.ItemSpec); } bool skip; foreach (var assemblyItem in Assemblies) { var assemblyPath = assemblyItem.ItemSpec; var fileName = Path.GetFileName(assemblyPath); if (MonoAndroidHelper.IsFrameworkAssembly(fileName) && !MonoAndroidHelper.FrameworkEmbeddedJarLookupTargets.Contains(fileName) && !MonoAndroidHelper.FrameworkEmbeddedNativeLibraryAssemblies.Contains(fileName)) { Log.LogDebugMessage($"Skipping framework assembly '{fileName}'."); continue; } if (DesignTimeBuild && !File.Exists(assemblyPath)) { Log.LogDebugMessage($"Skipping non-existent dependency '{assemblyPath}' during a design-time build."); continue; } if (bool.TryParse(assemblyItem.GetMetadata(GetAdditionalResourcesFromAssemblies.AndroidSkipResourceExtraction), out skip) && skip) { Log.LogDebugMessage("Skipping resource extraction for '{0}' .", assemblyPath); continue; } string assemblyFileName = Path.GetFileNameWithoutExtension(assemblyPath); string assemblyIdentName = assemblyFileName; if (UseShortFileNames) { assemblyIdentName = assemblyMap.GetLibraryImportDirectoryNameForAssembly(assemblyFileName); } string outDirForDll = Path.Combine(OutputImportDirectory, assemblyIdentName); string importsDir = Path.Combine(outDirForDll, ImportsDirectory); string nativeimportsDir = Path.Combine(outDirForDll, NativeImportsDirectory); string resDir = Path.Combine(importsDir, "res"); string assetsDir = Path.Combine(importsDir, "assets"); // Skip already-extracted resources. bool updated = false; string assemblyHash = MonoAndroidHelper.HashFile(assemblyPath); string stamp = Path.Combine(outdir, assemblyIdentName + ".stamp"); string stampHash = File.Exists(stamp) ? File.ReadAllText(stamp) : null; if (assemblyHash == stampHash) { Log.LogDebugMessage("Skipped resource lookup for {0}: extracted files are up to date", assemblyPath); if (Directory.Exists(importsDir)) { foreach (var file in Directory.EnumerateFiles(importsDir, "*.jar", SearchOption.AllDirectories)) { AddJar(jars, Path.GetFullPath(file)); } } if (Directory.Exists(resDir)) { var taskItem = new TaskItem(Path.GetFullPath(resDir), new Dictionary <string, string> { { OriginalFile, assemblyPath }, }); if (bool.TryParse(assemblyItem.GetMetadata(AndroidSkipResourceProcessing), out skip) && skip) { taskItem.SetMetadata(AndroidSkipResourceProcessing, "True"); } resolvedResourceDirectories.Add(taskItem); } if (Directory.Exists(assetsDir)) { resolvedAssetDirectories.Add(new TaskItem(Path.GetFullPath(assetsDir), new Dictionary <string, string> { { OriginalFile, assemblyPath } })); } foreach (var env in Directory.EnumerateFiles(outDirForDll, "__AndroidEnvironment__*", SearchOption.TopDirectoryOnly)) { resolvedEnvironments.Add(new TaskItem(env, new Dictionary <string, string> { { OriginalFile, assemblyPath } })); } continue; } Log.LogDebugMessage($"Refreshing {assemblyFileName}.dll"); var assembly = res.GetAssembly(assemblyPath); foreach (var mod in assembly.Modules) { // android environment files foreach (var envtxt in mod.Resources .Where(r => r.Name.StartsWith("__AndroidEnvironment__", StringComparison.OrdinalIgnoreCase)) .Where(r => r is EmbeddedResource) .Cast <EmbeddedResource> ()) { var outFile = Path.Combine(outDirForDll, envtxt.Name); using (var stream = envtxt.GetResourceStream()) { updated |= MonoAndroidHelper.CopyIfStreamChanged(stream, outFile); } resolvedEnvironments.Add(new TaskItem(Path.GetFullPath(outFile), new Dictionary <string, string> { { OriginalFile, assemblyPath } })); } // embedded jars (EmbeddedJar, EmbeddedReferenceJar) var resjars = mod.Resources .Where(r => r.Name.EndsWith(".jar", StringComparison.InvariantCultureIgnoreCase)) .Select(r => (EmbeddedResource)r); foreach (var resjar in resjars) { using (var stream = resjar.GetResourceStream()) { AddJar(jars, importsDir, resjar.Name, assemblyPath); updated |= MonoAndroidHelper.CopyIfStreamChanged(stream, Path.Combine(importsDir, resjar.Name)); } } var libzip = mod.Resources.FirstOrDefault(r => r.Name == "__AndroidNativeLibraries__.zip") as EmbeddedResource; if (libzip != null) { List <string> files = new List <string> (); using (var stream = libzip.GetResourceStream()) using (var zip = Xamarin.Tools.Zip.ZipArchive.Open(stream)) { try { updated |= Files.ExtractAll(zip, nativeimportsDir, modifyCallback: (entryFullName) => { files.Add(Path.GetFullPath(Path.Combine(nativeimportsDir, entryFullName))); return(entryFullName .Replace("native_library_imports\\", "") .Replace("native_library_imports/", "")); }, deleteCallback: (fileToDelete) => { return(!files.Contains(fileToDelete)); }); } catch (PathTooLongException ex) { Log.LogCodedError("XA4303", $"Error extracting resources from \"{assemblyPath}\": {ex}"); return; } catch (NotSupportedException ex) { Log.LogCodedError("XA4303", $"Error extracting resources from \"{assemblyPath}\": {ex}"); return; } } } // embedded AndroidResourceLibrary archive var reszip = mod.Resources.FirstOrDefault(r => r.Name == "__AndroidLibraryProjects__.zip") as EmbeddedResource; if (reszip != null) { // temporarily extracted directory will look like: // __library_projects__/[dllname]/[library_project_imports | jlibs]/bin using (var stream = reszip.GetResourceStream()) using (var zip = Xamarin.Tools.Zip.ZipArchive.Open(stream)) { try { updated |= Files.ExtractAll(zip, importsDir, modifyCallback: (entryFullName) => { var path = entryFullName .Replace("library_project_imports\\", "") .Replace("library_project_imports/", ""); if (path.EndsWith(".jar", StringComparison.OrdinalIgnoreCase)) { AddJar(jars, importsDir, path, assemblyPath); } return(path); }, deleteCallback: (fileToDelete) => { return(!jars.ContainsKey(fileToDelete)); }); } catch (PathTooLongException ex) { Log.LogCodedError("XA4303", $"Error extracting resources from \"{assemblyPath}\": {ex}"); return; } catch (NotSupportedException ex) { Log.LogCodedError("XA4303", $"Error extracting resources from \"{assemblyPath}\": {ex}"); return; } } // We used to *copy* the resources to overwrite other resources, // which resulted in missing resource issue. // Here we replaced copy with use of '-S' option and made it to work. if (Directory.Exists(resDir)) { var taskItem = new TaskItem(Path.GetFullPath(resDir), new Dictionary <string, string> { { OriginalFile, assemblyPath } }); if (bool.TryParse(assemblyItem.GetMetadata(AndroidSkipResourceProcessing), out skip) && skip) { taskItem.SetMetadata(AndroidSkipResourceProcessing, "True"); } resolvedResourceDirectories.Add(taskItem); } if (Directory.Exists(assetsDir)) { resolvedAssetDirectories.Add(new TaskItem(Path.GetFullPath(assetsDir), new Dictionary <string, string> { { OriginalFile, assemblyPath } })); } } } if (Directory.Exists(importsDir)) { // Delete unknown files in the top directory of importsDir foreach (var file in Directory.EnumerateFiles(importsDir, "*")) { var fullPath = Path.GetFullPath(file); if (file.StartsWith("__AndroidEnvironment__", StringComparison.OrdinalIgnoreCase) && !resolvedEnvironments.Any(x => x.ItemSpec == fullPath)) { Log.LogDebugMessage($"Deleting unknown AndroidEnvironment file: {Path.GetFileName (file)}"); File.Delete(fullPath); updated = true; } else if (file.EndsWith(".jar", StringComparison.OrdinalIgnoreCase) && !jars.ContainsKey(fullPath)) { Log.LogDebugMessage($"Deleting unknown jar: {Path.GetFileName (file)}"); File.Delete(fullPath); updated = true; } } if (assemblyHash != stampHash) { Log.LogDebugMessage($"Saving hash to {stamp}, changes: {updated}"); //NOTE: if the hash is different we always want to write the file, but preserve the timestamp if no changes WriteAllText(stamp, assemblyHash, preserveTimestamp: !updated); } } } foreach (var aarFile in AarLibraries ?? new ITaskItem[0]) { if (!File.Exists(aarFile.ItemSpec)) { continue; } string aarIdentityName = Path.GetFileNameWithoutExtension(aarFile.ItemSpec); if (UseShortFileNames) { aarIdentityName = assemblyMap.GetLibraryImportDirectoryNameForAssembly(aarIdentityName); } string outDirForDll = Path.Combine(OutputImportDirectory, aarIdentityName); string importsDir = Path.Combine(outDirForDll, ImportsDirectory); string resDir = Path.Combine(importsDir, "res"); string assetsDir = Path.Combine(importsDir, "assets"); bool updated = false; string aarHash = MonoAndroidHelper.HashFile(aarFile.ItemSpec); string stamp = Path.Combine(outdir, aarIdentityName + ".stamp"); string stampHash = File.Exists(stamp) ? File.ReadAllText(stamp) : null; var aarFullPath = Path.GetFullPath(aarFile.ItemSpec); if (aarHash == stampHash) { Log.LogDebugMessage("Skipped {0}: extracted files are up to date", aarFile.ItemSpec); if (Directory.Exists(importsDir)) { foreach (var file in Directory.EnumerateFiles(importsDir, "*.jar", SearchOption.AllDirectories)) { AddJar(jars, Path.GetFullPath(file)); } } if (Directory.Exists(resDir)) { resolvedResourceDirectories.Add(new TaskItem(Path.GetFullPath(resDir), new Dictionary <string, string> { { OriginalFile, Path.GetFullPath(aarFile.ItemSpec) }, { AndroidSkipResourceProcessing, "True" }, })); } if (Directory.Exists(assetsDir)) { resolvedAssetDirectories.Add(new TaskItem(Path.GetFullPath(assetsDir), new Dictionary <string, string> { { OriginalFile, aarFullPath }, })); } continue; } Log.LogDebugMessage($"Refreshing {aarFile.ItemSpec}"); // temporarily extracted directory will look like: // _lp_/[aarFile] using (var zip = MonoAndroidHelper.ReadZipFile(aarFile.ItemSpec)) { try { updated |= Files.ExtractAll(zip, importsDir, modifyCallback: (entryFullName) => { var entryFileName = Path.GetFileName(entryFullName); var entryPath = Path.GetDirectoryName(entryFullName); if (entryFileName.StartsWith("internal_impl", StringComparison.InvariantCulture)) { var hash = Files.HashString(entryFileName); var jar = Path.Combine(entryPath, $"internal_impl-{hash}.jar"); AddJar(jars, importsDir, jar, aarFullPath); return(jar); } if (entryFullName.EndsWith(".jar", StringComparison.OrdinalIgnoreCase)) { AddJar(jars, importsDir, entryFullName, aarFullPath); } return(entryFullName); }, deleteCallback: (fileToDelete) => { return(!jars.ContainsKey(fileToDelete)); }); if (Directory.Exists(importsDir) && aarHash != stampHash) { Log.LogDebugMessage($"Saving hash to {stamp}, changes: {updated}"); //NOTE: if the hash is different we always want to write the file, but preserve the timestamp if no changes WriteAllText(stamp, aarHash, preserveTimestamp: !updated); } } catch (PathTooLongException ex) { Log.LogErrorFromException(new PathTooLongException($"Error extracting resources from \"{aarFile.ItemSpec}\"", ex)); } } if (Directory.Exists(resDir)) { resolvedResourceDirectories.Add(new TaskItem(Path.GetFullPath(resDir), new Dictionary <string, string> { { OriginalFile, aarFullPath }, { AndroidSkipResourceProcessing, "True" }, })); } if (Directory.Exists(assetsDir)) { resolvedAssetDirectories.Add(new TaskItem(Path.GetFullPath(assetsDir), new Dictionary <string, string> { { OriginalFile, aarFullPath }, })); } } }
public override bool Execute() { Log.LogMessageFromText("Starting move", MessageImportance.Normal); bool allSucceeded = true; if (this.SourceFiles == null || this.SourceFiles.Length <= 0) { //if nothing to move just leave quietly this.DestinationFiles = new ITaskItem[0]; Log.LogMessageFromText("Nothing to move", MessageImportance.Normal); return(true); } if (this.DestinationFiles == null && this.DestinationFolder == null) { Log.LogError("Unable to determine destination for files"); return(false); } if (this.DestinationFiles != null && this.DestinationFolder != null) { Log.LogError("Both DestinationFiles & DestinationFolder were specified, only one can be provided"); return(false); } if (this.DestinationFiles != null && (this.DestinationFiles.Length != this.SourceFiles.Length)) { //# of items in source & dest don't match up Log.LogError("SourceFiles and DestinationFiles list have different sizes"); return(false); } this.FileLengths = new long[this.SourceFiles.Length]; if (this.DestinationFiles == null) { //populate from DestinationFolder this.DestinationFiles = new ITaskItem[this.SourceFiles.Length]; for (int i = 0; i < this.SourceFiles.Length; i++) { string destFile; try { destFile = Path.Combine(this.DestinationFolder.ItemSpec, Path.GetFileName(this.SourceFiles[i].ItemSpec)); } catch (Exception ex) { Log.LogError("Unable to move files; " + ex.Message, null); this.DestinationFiles = new ITaskItem[0]; return(false); } this.DestinationFiles[i] = new TaskItem(destFile); this.SourceFiles[i].CopyMetadataTo(this.DestinationFiles[i]); this.FileLengths[i] = new FileInfo(destFile).Length; } } MovedFiles = new ITaskItem[this.SourceFiles.Length]; //now we can go through and move all the files for (int i = 0; i < SourceFiles.Length; i++) { string sourcePath = this.SourceFiles[i].ItemSpec; string destPath = this.DestinationFiles[i].ItemSpec; try { string message = string.Format("Moving file {0} to {1}", sourcePath, destPath); Log.LogMessageFromText(message, MessageImportance.Normal); FileInfo destFile = new FileInfo(destPath); DirectoryInfo parentDir = destFile.Directory; if (!parentDir.Exists) { parentDir.Create(); } File.Move(sourcePath, destPath); MovedFiles[i] = new TaskItem(destPath); this.FileLengths[i] = destFile.Length; // chj adds this } catch (Exception ex) { Log.LogError("Unable to move file: " + sourcePath + " to " + destPath + "\n" + ex.Message); allSucceeded = false; } } return(allSucceeded); }
public TaskEntityMatchData(TaskItem task) { Subject = task.Subject; StartDate = task.StartDate; DueDate = task.DueDate; }
// private IBuildEngine buildEngine; /*public IBuildEngine BuildEngine * { * get * { * if (this.buildEngine == null) * { * //this.buildEngine = new SimpleBuildEngine(LogMessageEvent); * var vmb = new ViewModelBuildEngine(this.MessengerInstance); * vmb.Enabled = true; * this.buildEngine = vmb; * } * return buildEngine; * } * }*/ /// <summary> /// Prepares a task for display with an editor. /// </summary> /// <param name="taskTypeName">Name of the task type to instantiate.</param> /// <param name="taskAttributes">A list with the task attributes data.</param> /// <returns>A new task of the specified type, initialized with the data from the /// <paramref name="taskAttributes"/> list of Xml attributes.</returns> public ITask InitTaskEditor(string taskTypeName, IEnumerable <XmlAttribute> taskAttributes) { // var taskService = SimpleIoc.Default.GetInstance<ITaskService>(); var task = this.taskService[taskTypeName]; if (task == null) { return(null); } foreach (var item in taskAttributes) { var taskType = task.GetType(); var property = taskType.GetProperty(item.Name); if (property == null) { // Log property not found. continue; } if (property.PropertyType.IsArray) { // Log skipping array type. continue; } if (property != null) { object val = item.Value; if (property.PropertyType.Name == "ITaskItem") { val = new TaskItem(item.Value); } else { // try // { val = Convert.ChangeType(item.Value, property.PropertyType); // } // catch (Exception ex) // { // } } property.SetValue(task, val, null); } } // var dst = this.Task.data.AnyAttr.Where((e) => e.Name == "DestinationFolder").FirstOrDefault(); /*if (dst != null) * { * var val = dst.Value; * }*/ this.PrepareTask(task); this.taskInWork = task; return(task); // var str = XamlSerializer.Save(task); // SerializeTest(task); }
public void CreateNullNamedMetadata() { TaskItem item = new TaskItem("foo"); item.SetMetadata(null, "x"); }
private void PrecompileLibrary(ITaskItem assemblyItem) { string assembly = assemblyItem.ItemSpec; string directory = Path.GetDirectoryName(assembly) !; var aotAssembly = new TaskItem(assembly); var aotArgs = new List <string>(); var processArgs = new List <string>(); var a = assemblyItem.GetMetadata("AotArguments"); if (a != null) { aotArgs.AddRange(a.Split(";", StringSplitOptions.RemoveEmptyEntries)); } var p = assemblyItem.GetMetadata("ProcessArguments"); if (p != null) { processArgs.AddRange(p.Split(";", StringSplitOptions.RemoveEmptyEntries)); } Utils.LogInfo($"[AOT] {assembly}"); processArgs.Add("--debug"); // add LLVM options if (UseLLVM) { processArgs.Add("--llvm"); aotArgs.Add($"nodebug"); // can't use debug symbols with LLVM aotArgs.Add($"llvm-path={LLVMPath}"); } else { processArgs.Add("--nollvm"); } // compute output mode and file names if (parsedAotMode == MonoAotMode.LLVMOnly) { aotArgs.Add("llvmonly"); string llvmBitcodeFile = Path.ChangeExtension(assembly, ".dll.bc"); aotArgs.Add($"outfile={llvmBitcodeFile}"); aotAssembly.SetMetadata("LlvmBitcodeFile", llvmBitcodeFile); } else { if (parsedAotMode == MonoAotMode.Full) { aotArgs.Add("full"); } if (parsedOutputType == MonoAotOutputType.AsmOnly) { aotArgs.Add("asmonly"); string assemblerFile = Path.ChangeExtension(assembly, ".dll.s"); aotArgs.Add($"outfile={assemblerFile}"); aotAssembly.SetMetadata("AssemblerFile", assemblerFile); } else { string objectFile = Path.ChangeExtension(assembly, ".dll.o"); aotArgs.Add($"outfile={objectFile}"); aotAssembly.SetMetadata("ObjectFile", objectFile); } if (UseLLVM) { string llvmObjectFile = Path.ChangeExtension(assembly, ".dll-llvm.o"); aotArgs.Add($"llvm-outfile={llvmObjectFile}"); aotAssembly.SetMetadata("LlvmObjectFile", llvmObjectFile); } } // pass msym-dir if specified if (MsymPath != null) { aotArgs.Add($"msym-dir={MsymPath}"); } string aotDataFile = Path.ChangeExtension(assembly, ".aotdata"); aotArgs.Add($"data-outfile={aotDataFile}"); aotAssembly.SetMetadata("AotDataFile", aotDataFile); // we need to quote the entire --aot arguments here to make sure it is parsed // on Windows as one argument. Otherwise it will be split up into multiple // values, which wont work. processArgs.Add($"\"--aot={String.Join(",", aotArgs)}\""); processArgs.Add(assembly); var envVariables = new Dictionary <string, string> { { "MONO_PATH", directory }, { "MONO_ENV_OPTIONS", String.Empty } // we do not want options to be provided out of band to the cross compilers }; // run the AOT compiler Utils.RunProcess(CompilerBinaryPath, String.Join(" ", processArgs), envVariables, directory); compiledAssemblies.Add(aotAssembly); }
public void VerifyAssemblyPulledOutOfFrameworkDoesntGetFrameworkFileAttribute() { MockEngine e = new MockEngine(); string actualFrameworkDirectory = @"c:\WINNT\Microsoft.NET\Framework\v2.0.MyVersion"; string alternativeFrameworkDirectory = @"c:\WINNT\Microsoft.NET\Framework\v4.0.MyVersion"; ITaskItem[] items = new TaskItem[] { new TaskItem(Path.Combine(actualFrameworkDirectory, "System.dll")) }; // Version and directory match framework - it is a framework assembly string redistString1 = "<FileList Redist='Microsoft-Windows-CLRCoreComp-Random' >" + "<File AssemblyName='System' Version='2.0.0.0' PublicKeyToken='b77a5c561934e089' Culture='neutral' ProcessorArchitecture='MSIL' FileVersion='4.0.0.0' InGAC='true' />" + "</FileList >"; ResolveAssemblyReference t1 = new ResolveAssemblyReference(); t1.TargetFrameworkVersion = "v4.5"; t1.TargetFrameworkDirectories = new string[] { actualFrameworkDirectory }; ExecuteRAROnItemsAndRedist(t1, e, items, redistString1, true, new List <string>() { "{RawFileName}" }); Assert.False(String.IsNullOrEmpty(t1.ResolvedFiles[0].GetMetadata("FrameworkFile"))); // Higher version than framework, but directory matches - it is a framework assembly string redistString2 = "<FileList Redist='Microsoft-Windows-CLRCoreComp-Random' >" + "<File AssemblyName='System' Version='1.0.0.0' PublicKeyToken='b77a5c561934e089' Culture='neutral' ProcessorArchitecture='MSIL' FileVersion='4.0.0.0' InGAC='true' />" + "</FileList >"; ResolveAssemblyReference t2 = new ResolveAssemblyReference(); t2.TargetFrameworkVersion = "v4.5"; t2.TargetFrameworkDirectories = new string[] { actualFrameworkDirectory }; ExecuteRAROnItemsAndRedist(t2, e, items, redistString2, true, new List <string>() { "{RawFileName}" }); Assert.False(String.IsNullOrEmpty(t2.ResolvedFiles[0].GetMetadata("FrameworkFile"))); // Version is lower but directory does not match - it is a framework assembly string redistString3 = "<FileList Redist='Microsoft-Windows-CLRCoreComp-Random' >" + "<File AssemblyName='System' Version='3.0.0.0' PublicKeyToken='b77a5c561934e089' Culture='neutral' ProcessorArchitecture='MSIL' FileVersion='4.0.0.0' InGAC='true' />" + "</FileList >"; ResolveAssemblyReference t3 = new ResolveAssemblyReference(); t3.TargetFrameworkVersion = "v4.5"; t3.TargetFrameworkDirectories = new string[] { alternativeFrameworkDirectory }; ExecuteRAROnItemsAndRedist(t3, e, items, redistString3, true, new List <string>() { "{RawFileName}" }); Assert.False(String.IsNullOrEmpty(t3.ResolvedFiles[0].GetMetadata("FrameworkFile"))); // Version is higher and directory does not match - this assembly has been pulled out of .NET string redistString4 = "<FileList Redist='Microsoft-Windows-CLRCoreComp-Random' >" + "<File AssemblyName='System' Version='1.0.0.0' PublicKeyToken='b77a5c561934e089' Culture='neutral' ProcessorArchitecture='MSIL' FileVersion='4.0.0.0' InGAC='true' />" + "</FileList >"; ResolveAssemblyReference t4 = new ResolveAssemblyReference(); t4.TargetFrameworkVersion = "v4.5"; t4.TargetFrameworkDirectories = new string[] { alternativeFrameworkDirectory }; ExecuteRAROnItemsAndRedist(t4, e, items, redistString4, true, new List <string>() { "{RawFileName}" }); Assert.True(String.IsNullOrEmpty(t4.ResolvedFiles[0].GetMetadata("FrameworkFile"))); }
/// <summary> /// Определение статуса PLM по статусу KS.Gantt // </summary> public NamedValue GetStatusPLM(TaskItem.TaskStates status) { return dictStatus[(int)status]; }
private bool UpdateTask(TaskItem taskItem, ReminderTask reminderTask) { try { taskItem.Subject = reminderTask.Title; taskItem.Body = reminderTask.Notes; taskItem.DueDate = reminderTask.Due.GetValueOrDefault(); taskItem.StartDate = reminderTask.StartDate; taskItem.Complete = reminderTask.IsCompleted; if (reminderTask.IsCompleted) { taskItem.DateCompleted = reminderTask.CompletedOn.GetValueOrDefault(); } taskItem.Status = reminderTask.GetOlTaskStatus(); taskItem.Save(); return true; } catch (Exception exception) { Logger.Error(exception); return false; } }
/* * AddCodeTask */ /// <summary> /// </summary> /// <exception cref="ArgumentNullException"> /// <paramref name="taskItemToAdd"/> is <see langword="null"/>. /// </exception> public void AddCodeTask(TaskItem taskItemToAdd) { if (taskItemToAdd == null) { throw new ArgumentNullException("taskItemToAdd"); } NuGenCodeTaskTreeNode codeTaskNode = new NuGenCodeTaskTreeNode( this.ServiceProvider ); this.InitializeCodeTask(codeTaskNode); Debug.Assert(this.CodeTasks != null, "this.CodeTasks != null"); this.CodeTasks.Add(codeTaskNode, taskItemToAdd); Debug.Assert(this.CommentsFolder != null, "this.CommentsFolder != null"); this.CommentsFolder.Nodes.AddNode(codeTaskNode); codeTaskNode.Text = taskItemToAdd.Description; }
// POST api/task public void CreateTask([FromBody] TaskItem taskItem) { _taskService.Create(taskItem); }
public override bool Execute() { PDictionary plist; PString value; try { plist = PDictionary.FromFile(AppManifest.ItemSpec); } catch (Exception ex) { Log.LogError(null, null, null, AppManifest.ItemSpec, 0, 0, 0, 0, MSBStrings.E0055, ex.Message); return(false); } // deviceType = plist.GetUIDeviceFamily (); if (plist.TryGetValue(ManifestKeys.MinimumOSVersion, out value)) { if (!IPhoneSdkVersion.TryParse(value.Value, out minimumOSVersion)) { Log.LogError(null, null, null, AppManifest.ItemSpec, 0, 0, 0, 0, MSBStrings.E0011, value); return(false); } } else { switch (Platform) { case ApplePlatform.iOS: IPhoneSdkVersion sdkVersion; if (!IPhoneSdkVersion.TryParse(SdkVersion, out sdkVersion)) { Log.LogError(null, null, null, AppManifest.ItemSpec, 0, 0, 0, 0, MSBStrings.E0056, SdkVersion); return(false); } minimumOSVersion = sdkVersion; break; case ApplePlatform.WatchOS: case ApplePlatform.TVOS: minimumOSVersion = IPhoneSdkVersion.UseDefault; break; default: throw new InvalidOperationException(string.Format("Invalid framework: {0}", Platform)); } } Directory.CreateDirectory(AppBundleDir); var executableLastWriteTime = default(DateTime); var executable = Path.Combine(AppBundleDir, ExecutableName); if (File.Exists(executable)) { executableLastWriteTime = File.GetLastWriteTimeUtc(executable); } var result = base.Execute(); CopiedFrameworks = GetCopiedFrameworks(); if (File.Exists(executable) && File.GetLastWriteTimeUtc(executable) != executableLastWriteTime) { NativeExecutable = new TaskItem(executable); } return(result); }
public override bool Execute() { if (Environment.GetEnvironmentVariable("DEBUG_NUGETIZER") == "1") { Debugger.Launch(); } var packages = new ConcurrentDictionary <PackageIdentity, List <PackageIdentity> >(); Func <string, PackageIdentity> parse = value => { var parts = value.Split('/'); return(new PackageIdentity(parts[0], parts[1])); }; // Build the list of parent>child relationships. foreach (var dependency in PackageDependencies.Where(x => x.ItemSpec.Contains('/'))) { var identity = parse(dependency.ItemSpec); var parent = dependency.GetMetadata("ParentPackage"); if (!string.IsNullOrEmpty(parent)) { packages.GetOrAdd(parse(parent), _ => new List <PackageIdentity>()) .Add(identity); } else { // In centrally managed package versions, at this point we have // the right version if the project is using centrally managed versions var primaryReference = PackageReferences.FirstOrDefault(x => x.ItemSpec == identity.Id); if (primaryReference != null && primaryReference.GetNullableMetadata("Version") == null) { primaryReference.SetMetadata("Version", identity.Version); } } } var inferred = new Dictionary <PackageIdentity, ITaskItem>(); foreach (var reference in PackageReferences) { var identity = new PackageIdentity(reference.ItemSpec, reference.GetMetadata("Version")); var originalMetadata = (IDictionary <string, string>)reference.CloneCustomMetadata(); foreach (var dependency in FindDependencies(identity, packages)) { if (!inferred.ContainsKey(dependency)) { var item = new TaskItem(dependency.Id); foreach (var metadata in originalMetadata) { item.SetMetadata(metadata.Key, metadata.Value); } item.SetMetadata("Version", dependency.Version); inferred.Add(dependency, item); } } } ImplicitPackageReferences = inferred.Values.ToArray(); return(true); }
public override bool Execute() { var intermediate = Path.Combine(IntermediateOutputPath, ToolName); var intermediateBundleDir = Path.Combine(intermediate, "bundle"); var intermediateCloneDir = Path.Combine(intermediate, "cloned-assets"); var manifest = new TaskItem(Path.Combine(intermediate, "asset-manifest.plist")); var bundleResources = new List <ITaskItem> (); var outputManifests = new List <ITaskItem> (); var catalogs = new List <ITaskItem> (); var unique = new HashSet <string> (); var knownSpecs = new HashSet <string> (); var clones = new HashSet <string> (); var items = new List <ITaskItem> (); var specs = new PArray(); if (AppManifest != null) { try { plist = PDictionary.FromFile(AppManifest.ItemSpec); } catch (Exception ex) { Log.LogError(null, null, null, AppManifest.ItemSpec, 0, 0, 0, 0, "{0}", ex.Message); return(false); } } for (int i = 0; i < ImageAssets.Length; i++) { var vpath = BundleResource.GetVirtualProjectPath(ProjectDir, ImageAssets[i], !string.IsNullOrEmpty(SessionId)); // Ignore MacOS .DS_Store files... if (Path.GetFileName(vpath).Equals(".DS_Store", StringComparison.OrdinalIgnoreCase)) { continue; } // get the parent (which will typically be .appiconset, .launchimage, .imageset, .iconset, etc) var catalog = Path.GetDirectoryName(vpath); // keep walking up the directory structure until we get to the .xcassets directory while (!string.IsNullOrEmpty(catalog) && Path.GetExtension(catalog) != ".xcassets") { catalog = Path.GetDirectoryName(catalog); } if (string.IsNullOrEmpty(catalog)) { Log.LogWarning(null, null, null, ImageAssets[i].ItemSpec, 0, 0, 0, 0, MSBStrings.W0090, ImageAssets[i].ItemSpec); continue; } if (ImageAssets[i].GetMetadata("Link") != null) { // Note: if any of the files within a catalog are linked, we'll have to clone the *entire* catalog clones.Add(catalog); continue; } // filter out everything except paths containing a Contents.json file since our main processing loop only cares about these if (Path.GetFileName(vpath) != "Contents.json") { continue; } items.Add(ImageAssets[i]); } // clone any *.xcassets dirs that need cloning if (clones.Count > 0) { if (Directory.Exists(intermediateCloneDir)) { Directory.Delete(intermediateCloneDir, true); } Directory.CreateDirectory(intermediateCloneDir); items.Clear(); for (int i = 0; i < ImageAssets.Length; i++) { var vpath = BundleResource.GetVirtualProjectPath(ProjectDir, ImageAssets[i], !string.IsNullOrEmpty(SessionId)); var clone = false; ITaskItem item; // Ignore MacOS .DS_Store files... if (Path.GetFileName(vpath).Equals(".DS_Store", StringComparison.OrdinalIgnoreCase)) { continue; } foreach (var catalog in clones) { if (vpath.Length > catalog.Length && vpath[catalog.Length] == '/' && vpath.StartsWith(catalog, StringComparison.Ordinal)) { clone = true; break; } } if (clone) { var src = ImageAssets[i].GetMetadata("FullPath"); if (!File.Exists(src)) { Log.LogError(null, null, null, src, 0, 0, 0, 0, MSBStrings.E0091, src); return(false); } var dest = Path.Combine(intermediateCloneDir, vpath); var dir = Path.GetDirectoryName(dest); Directory.CreateDirectory(dir); File.Copy(src, dest, true); // filter out everything except paths containing a Contents.json file since our main processing loop only cares about these if (Path.GetFileName(vpath) != "Contents.json") { continue; } item = new TaskItem(dest); ImageAssets[i].CopyMetadataTo(item); item.SetMetadata("Link", vpath); } else { // filter out everything except paths containing a Contents.json file since our main processing loop only cares about these if (Path.GetFileName(vpath) != "Contents.json") { continue; } item = ImageAssets[i]; } items.Add(item); } } // Note: `items` contains only the Contents.json files at this point for (int i = 0; i < items.Count; i++) { var vpath = BundleResource.GetVirtualProjectPath(ProjectDir, items[i], !string.IsNullOrEmpty(SessionId)); var path = items[i].GetMetadata("FullPath"); // get the parent (which will typically be .appiconset, .launchimage, .imageset, .iconset, etc) var catalog = Path.GetDirectoryName(vpath); path = Path.GetDirectoryName(path); // keep walking up the directory structure until we get to the .xcassets directory while (!string.IsNullOrEmpty(catalog) && Path.GetExtension(catalog) != ".xcassets") { catalog = Path.GetDirectoryName(catalog); path = Path.GetDirectoryName(path); } if (unique.Add(catalog)) { var item = new TaskItem(path); item.SetMetadata("Link", catalog); catalogs.Add(item); } if (AppleSdkSettings.XcodeVersion.Major >= 7 && SdkPlatform != "WatchSimulator") { var text = File.ReadAllText(items[i].ItemSpec); if (string.IsNullOrEmpty(text)) { continue; } JsonDocument json; JsonElement value; try { var options = new JsonDocumentOptions() { AllowTrailingCommas = true, }; json = JsonDocument.Parse(text, options); } catch (JsonException je) { var line = (int)(je.LineNumber + 1 ?? 0); var col = (int)(je.BytePositionInLine + 1 ?? 0); Log.LogError(null, null, null, items [i].ItemSpec, line, col, line, col, "{0}", je.Message); return(false); } catch (Exception e) { Log.LogError(null, null, null, items[i].ItemSpec, 0, 0, 0, 0, MSBStrings.E0092, e.Message); return(false); } if (!json.RootElement.TryGetProperty("properties", out value) || value.ValueKind != JsonValueKind.Object) { continue; } var properties = value; if (!properties.TryGetProperty("on-demand-resource-tags", out value) || value.ValueKind != JsonValueKind.Array) { continue; } var resourceTags = value; var tags = new HashSet <string> (); string hash; foreach (var tag in resourceTags.EnumerateArray()) { if (tag.ValueKind == JsonValueKind.String) { tags.Add(tag.GetString()); } } var tagList = tags.ToList(); tagList.Sort(); var assetDir = AssetPackUtils.GetAssetPackDirectory(intermediate, BundleIdentifier, tagList, out hash); if (knownSpecs.Add(hash)) { var assetpack = new PDictionary(); var ptags = new PArray(); Directory.CreateDirectory(assetDir); for (int j = 0; j < tagList.Count; j++) { ptags.Add(new PString(tagList[j])); } assetpack.Add("bundle-id", new PString(string.Format("{0}.asset-pack-{1}", BundleIdentifier, hash))); assetpack.Add("bundle-path", new PString(Path.GetFullPath(assetDir))); assetpack.Add("tags", ptags); specs.Add(assetpack); } } } if (catalogs.Count == 0) { // There are no (supported?) asset catalogs return(!Log.HasLoggedErrors); } partialAppManifest = new TaskItem(Path.Combine(intermediate, "partial-info.plist")); if (specs.Count > 0) { outputSpecs = Path.Combine(intermediate, "output-specifications.plist"); specs.Save(outputSpecs, true); } Directory.CreateDirectory(intermediateBundleDir); // Note: Compile() will set the PartialAppManifest property if it is used... if ((Compile(catalogs.ToArray(), intermediateBundleDir, manifest)) != 0) { return(false); } if (PartialAppManifest != null && !File.Exists(PartialAppManifest.GetMetadata("FullPath"))) { Log.LogError(MSBStrings.E0093, PartialAppManifest.GetMetadata("FullPath")); } try { var manifestOutput = PDictionary.FromFile(manifest.ItemSpec); LogWarningsAndErrors(manifestOutput, catalogs[0]); bundleResources.AddRange(GetCompiledBundleResources(manifestOutput, intermediateBundleDir)); outputManifests.Add(manifest); } catch (Exception ex) { Log.LogError(MSBStrings.E0094, ToolName, manifest.ItemSpec, ex.Message); } foreach (var assetpack in specs.OfType <PDictionary> ()) { var path = Path.Combine(assetpack.GetString("bundle-path").Value, "Info.plist"); var bundlePath = PathUtils.AbsoluteToRelative(intermediate, path); var outputPath = Path.Combine(OutputPath, bundlePath); var rpath = Path.Combine(intermediate, bundlePath); var dict = new PDictionary(); dict.SetCFBundleIdentifier(assetpack.GetString("bundle-id").Value); dict.Add("Tags", assetpack.GetArray("tags").Clone()); dict.Save(path, true, true); var item = new TaskItem(rpath); item.SetMetadata("LogicalName", bundlePath); item.SetMetadata("OutputPath", outputPath); item.SetMetadata("Optimize", "false"); bundleResources.Add(item); } BundleResources = bundleResources.ToArray(); OutputManifests = outputManifests.ToArray(); return(!Log.HasLoggedErrors); }
public override bool Execute() { if (string.IsNullOrEmpty(NoSymbolStrip)) { NoSymbolStrip = "false"; } if (string.IsNullOrEmpty(NoDSymUtil)) { NoDSymUtil = "false"; } if (!string.IsNullOrEmpty(ExtraArgs)) { var args = CommandLineArgumentBuilder.Parse(ExtraArgs); List <string> xml = null; var envVariables = new List <ITaskItem> (); var dlsyms = new List <ITaskItem> (); for (int i = 0; i < args.Length; i++) { var arg = args [i]; if (string.IsNullOrEmpty(arg)) { continue; } var index = 1; if (arg [0] == '/') { // nothing to do } else if (arg [0] == '-') { if (arg.Length >= 2 && arg [1] == '-') { index++; } } else { continue; } arg = arg.Substring(index); var separators = new char [] { ':', '=' }; var eq = arg.IndexOfAny(separators); var value = string.Empty; var name = arg; var nextValue = string.Empty; var hasValue = false; if (eq >= 0) { name = arg.Substring(0, eq); value = arg.Substring(eq + 1); hasValue = true; } else if (i < args.Length - 1) { nextValue = args [i + 1]; } switch (name) { case "nosymbolstrip": // There's also a version that takes symbols as arguments: // --nosymbolstrip:symbol1,symbol2 // in that case we do want to run the SymbolStrip target, so we // do not set the MtouchNoSymbolStrip property to 'true' in that case. NoSymbolStrip = string.IsNullOrEmpty(value) ? "true" : "false"; break; case "dlsym": dlsyms.Add(new TaskItem(string.IsNullOrEmpty(value) ? "true" : value)); break; case "dsym": NoDSymUtil = ParseBool(value) ? "false" : "true"; break; case "verbose": case "v": Verbosity++; break; case "quiet": case "q": Verbosity--; break; case "marshal-managed-exceptions": value = hasValue ? value : nextValue; // requires a value, which might be the next option MarshalManagedExceptionMode = value; break; case "marshal-objectivec-exceptions": value = hasValue ? value : nextValue; // requires a value, which might be the next option MarshalObjectiveCExceptionMode = value; break; case "custom_bundle_name": value = hasValue ? value : nextValue; // requires a value, which might be the next option CustomBundleName = value; break; case "optimize": if (!string.IsNullOrEmpty(Optimize)) { Optimize += ","; } Optimize += value; break; case "registrar": value = hasValue ? value : nextValue; // requires a value, which might be the next option Registrar = value; break; case "setenv": value = hasValue ? value : nextValue; // requires a value, which might be the next option var colon = value.IndexOfAny(separators); var item = new TaskItem(value.Substring(0, colon)); item.SetMetadata("Value", value.Substring(colon + 1)); envVariables.Add(item); break; case "xml": if (xml == null) { xml = new List <string> (); } value = hasValue ? value : nextValue; // requires a value, which might be the next option xml.Add(value); break; case "nostrip": // Output is EnableAssemblyILStripping so we enable if --nostrip=false and disable if true NoStrip = ParseBool(value) ? "false" : "true"; break; default: Log.LogMessage(MessageImportance.Low, "Skipping unknown argument '{0}' with value '{1}'", name, value); break; } } if (xml != null) { var defs = new List <ITaskItem> (); if (XmlDefinitions != null) { defs.AddRange(XmlDefinitions); } foreach (var x in xml) { defs.Add(new TaskItem(x)); } XmlDefinitions = defs.ToArray(); } if (envVariables.Count > 0) { if (EnvironmentVariables != null) { envVariables.AddRange(EnvironmentVariables); } EnvironmentVariables = envVariables.ToArray(); } if (dlsyms.Count > 0) { if (DlSym != null) { dlsyms.AddRange(DlSym); } DlSym = dlsyms.ToArray(); } } return(!Log.HasLoggedErrors); }
public void CreateEmptyNamedMetadata() { TaskItem item = new TaskItem("foo"); item.SetMetadata("", "x"); }
List <TaskItem> InitTaskItem(JsonData jd) { List <TaskItem> taskitem = new List <TaskItem> (); for (int i = 0; i < jd.Count; i++) { TaskItem ti = new TaskItem(); ti._Id = int.Parse((string)jd[i]["_id"]); int id; if (jd[i]["_task"] == null) { id = 0; } else { id = int.Parse((string)jd[i]["_task"]); } Task t = null; if (taskList.TryGetValue(id, out t)) { ti._Task = MakeNewTask(t); } switch ((string)jd[i]["_taskProgress"]) { case "Accept": ti._TaskProgress = TaskProgress.Accept; break; case "Complete": ti._TaskProgress = TaskProgress.Complete; break; case "NoStart": ti._TaskProgress = TaskProgress.NoStart; break; case "Reward": ti._TaskProgress = TaskProgress.Reward; break; } switch ((string)jd[i]["_taskType"]) { case "Main": ti._TaskType = TaskType.Main; break; case "Reward": ti._TaskType = TaskType.Reward; break; case "Daily": ti._TaskType = TaskType.Daily; break; } ti._IdTranscript = int.Parse((string)jd[i]["_idTranscript"]); ti._OwnName = (string)jd[i]["_ownName"]; if (id == 0) { ti._Name = (string)jd[i]["_name"]; ti._Des = (string)jd[i]["_des"]; ti._Coin = int.Parse((string)jd[i]["_coin"]); ti._Diamond = int.Parse((string)jd[i]["_diamond"]); ti._Mine = int.Parse((string)jd[i]["_mine"]); ti._Ruby = int.Parse((string)jd[i]["_ruby"]); ti._Treasure = int.Parse((string)jd[i]["_treasure"]); ti._Power = int.Parse((string)jd[i]["_power"]); ti._Feats = int.Parse((string)jd[i]["_feats"]); } taskitem.Add(ti); } return(taskitem); }
/// <summary> /// Prepares the 'SourceFiles', etc., <see cref="TaskItem"/> data. /// </summary> /// <param name="task">The task to prepare.</param> /// <remarks> /// This is experimental. Uncommenting the "cr.Execute()" line below, fills the /// SourceFiles property of a Backup-Task in the editor with the evaluated path data. /// A <see cref="CreateItem"/> task is used to mimic the work of a project build engine. /// </remarks> private void PrepareTask(ITask task) { // Todo: put this task generation extra. /*for (int index = 0; index < this.Paths.Count; index++) * { * var item = this.Paths[index]; * }*/ // int xasd = 0; var result = this.Paths.Select( e => { var cr = new CreateItem(); if (e.Inclusion.Count > 0) { cr.Include = e.Inclusion.Select( t => { if (e.Path.EndsWith("\\")) { return(new TaskItem(e.Path + t.Pattern)); } else { return(new TaskItem(e.Path + "\\" + t.Pattern)); } } ).ToArray(); } else { ITaskItem taskItem; var finfo = new FileInfo(e.Path); if (Directory.Exists(e.Path)) { // a directory taskItem = new TaskItem(e.Path + "\\" + recursivePattern); } else { // a file taskItem = new TaskItem(e.Path); } cr.Include = new[] { taskItem }; } cr.Exclude = e.Exclusion.Select((t) => { return(new TaskItem(e.Path + "\\" + t.Pattern)); }).ToArray(); // at the moment, do not execute the items. // cr.Execute(); return(cr); } ); if (task is Backup) { var btask = (Backup)task; // var res = result.ToArray(); var includes = result.SelectMany((e) => e.Include); btask.SourceFiles = includes.ToArray(); // btask.DestinationFolder = new TaskItem(@"C:\tmp\%(RecursiveDir)"); // var itemsByType = new Hashtable(); // foreach (var item in btask.SourceFiles) // { // itemsByType.Add( // } // var bla = ItemExpander.ItemizeItemVector(@"@(File)", null, itemsByType); // Todo: do i need the build engine ? // btask.BuildEngine = this.BuildEngine; } }
public TaskItem Create(TaskItem taskItem) { taskItem.Id = Tasks.Count() + 1; Tasks.Add(taskItem); return(taskItem); }
/// <summary> /// Returns a string with those switches and other information that can't go into a response file and /// must go directly onto the command line. /// Called after ValidateParameters and SkipTaskExecution /// </summary> override protected string GenerateCommandLineCommands() { CommandLineBuilderExtension commandLineBuilder = new CommandLineBuilderExtension(); bool serializationAssemblyPathExists = false; try { if (SerializationAssembly == null) { Debug.Assert(ShouldGenerateSerializer, "GenerateCommandLineCommands() should not be called if ShouldGenerateSerializer is true and SerializationAssembly is null."); SerializationAssembly = new TaskItem[] { new TaskItem(SerializationAssemblyPath) }; } // Add the assembly switch commandLineBuilder.AppendSwitchIfNotNull("/assembly:", AssemblyFullPath); commandLineBuilder.AppendWhenTrue("/proxytypes", Bag, "UseProxyTypes"); //add the keep switch commandLineBuilder.AppendWhenTrue("/keep", Bag, "UseKeep"); // Append the references, if any. if (References != null) { foreach (string reference in References) { commandLineBuilder.AppendSwitchIfNotNull("/reference:", reference); } } //Append the Types to the command line, if any. if (Types != null) { foreach (string type in Types) { commandLineBuilder.AppendSwitchIfNotNull("/type:", type); } } // The arguments to the "/compiler" switch are themselves switches to be passed to // the compiler when generating the serialization assembly. // Add the compiler command switches for strong naming on the serialization assembly if (KeyFile != null) { commandLineBuilder.AppendNestedSwitch("/compiler:", "/keyfile:", KeyFile); } else if (KeyContainer != null) { commandLineBuilder.AppendNestedSwitch("/compiler:", "/keycontainer:", KeyContainer); } commandLineBuilder.AppendPlusOrMinusSwitch("/compiler:/delaysign", Bag, "DelaySign"); // Add the Platform switch to the compiler. if (Platform != null) { commandLineBuilder.AppendNestedSwitch("/compiler:", "/platform:", Platform); } serializationAssemblyPathExists = File.Exists(SerializationAssemblyPath); } catch (Exception e) when(ExceptionHandling.IsIoRelatedException(e)) { // Ignore the expected exceptions because they have already been logged } // Delete the assembly if it already exists. if (serializationAssemblyPathExists) { try { File.Delete(SerializationAssemblyPath); } // Of all of the exceptions that can be thrown on a File.Delete, the only ones we need to // be immediately concerned with are the UnauthorizedAccessException and the IOException // (file is in use exception). We need to make sure that the assembly is gone before we // try to produce a new one because it is possible that after some changes were made to the // base assembly, there will, in fact, not be a serialization assembly produced. We cannot // leave the earlier produced assembly around to be propagated by later processes. catch (UnauthorizedAccessException e) { Log.LogErrorWithCodeFromResources("SGen.CouldNotDeleteSerializer", SerializationAssemblyPath, e.Message); } catch (IOException e) { Log.LogErrorWithCodeFromResources("SGen.CouldNotDeleteSerializer", SerializationAssemblyPath, e.Message); } // The DirectoryNotFoundException is safely ignorable since that means that there is no // existing serialization assembly. This would be extremely unlikely anyway because we // found the serializer just a couple of milliseconds ago. } return(commandLineBuilder.ToString()); }
public TaskItemWrapper(TaskItem inner, Func <string, TaskItem> load) { _load = load; Inner = inner; }
private async Task DeleteAsync(MusicDb db, PathData pd) { db.ChangeTracker.AutoDetectChangesEnabled = false; taskItem = await db.TaskItems.FindAsync(taskId); IEnumerable <MusicFile> musicFileList = null; string path = ""; if (pd.GetFullOpusPath() != null) { path = pd.IsCollections ? pd.OpusPath : $"{pd.ArtistPath}\\{pd.OpusPath}"; musicFileList = db.MusicFiles .Where(f => (f.DiskRoot.ToLower() == pd.DiskRoot.ToLower()) && (f.StylePath.ToLower() == pd.StylePath.ToLower()) && (f.OpusPath.ToLower() == path.ToLower())) .OrderBy(f => f.File) ; } else { if (pd.IsCollections) { musicFileList = db.MusicFiles .Where(f => (f.DiskRoot.ToLower() == pd.DiskRoot.ToLower()) && (f.StylePath.ToLower() == pd.StylePath.ToLower()) && f.Musician.ToLower() == "collections") .OrderBy(f => f.File) ; } else { musicFileList = db.MusicFiles .Where(f => (f.DiskRoot.ToLower() == pd.DiskRoot.ToLower()) && (f.StylePath.ToLower() == pd.StylePath.ToLower()) && f.OpusPath.StartsWith(pd.ArtistPath)) .OrderBy(f => f.File) ; } } log.Information($"Deleting {musicFileList.Count()} music files"); var dc = new DeleteContext(taskItem); foreach (var mf in musicFileList) { db.Delete(mf, dc); } taskItem.Status = Music.Core.TaskStatus.Finished; taskItem.FinishedAt = DateTimeOffset.Now; await db.SaveChangesAsync(); if (dc.DeletedArtistId.HasValue) { await this.playManager.SendArtistDeleted(dc.DeletedArtistId.Value); } else if (dc.ModifiedArtistId.HasValue) { var shouldSend = true; var artist = await db.Artists.FindAsync(dc.ModifiedArtistId.Value); if (artist != null) { shouldSend = artist.Type != ArtistType.Various; } if (shouldSend) { await this.playManager.SendArtistNewOrModified(dc.ModifiedArtistId.Value); } } //if (dc.DeletedArtistId.HasValue || dc.ModifiedArtistId.HasValue) //{ // var shouldSend = true; // var id = dc.ModifiedArtistId ?? 0; // if (id > 0) // { // var artist = await db.Artists.FindAsync(id); // shouldSend = artist.Type != ArtistType.Various; // } // if (shouldSend) // { // if (dc.DeletedArtistId.HasValue) // { // await this.playManager.SendArtistDeleted(dc.DeletedArtistId.Value); // } // else if (dc.ModifiedArtistId.HasValue) // { // await this.playManager.SendArtistNewOrModified(dc.ModifiedArtistId.Value); // } // } //} // send artist modified/deleted - info is in dc }
// Resolves by looking dependency_search_paths // which is dir of parent reference file, and // SearchPaths ResolvedReference ResolveDependencyByAssemblyName(AssemblyName aname, string parent_asm_name, string parent_copy_local) { // This will check for compatible assembly name/version ResolvedReference resolved_ref; if (TryGetResolvedReferenceByAssemblyName(aname, false, out resolved_ref)) { return(resolved_ref); } LogWithPrecedingNewLine(MessageImportance.Low, "Dependency {0}", aname); Log.LogMessage(MessageImportance.Low, "\tRequired by {0}", parent_asm_name); ITaskItem item = new TaskItem(aname.FullName); item.SetMetadata("SpecificVersion", "false"); resolved_ref = ResolveReference(item, dependency_search_paths, false); if (resolved_ref != null) { if (Environment.GetEnvironmentVariable("XBUILD_LOG_REFERENCE_RESOLVER") != null) { assembly_resolver.LogSearchLoggerMessages(MessageImportance.Low); } Log.LogMessage(MessageImportance.Low, "\tReference {0} resolved to {1}.", aname, resolved_ref.TaskItem.ItemSpec); Log.LogMessage(MessageImportance.Low, "\tReference found at search path {0}", resolved_ref.FoundInSearchPathAsString); if (resolved_ref.FoundInSearchPath == SearchPath.Directory) { // override CopyLocal with parent's val SetCopyLocal(resolved_ref.TaskItem, parent_copy_local); Log.LogMessage(MessageImportance.Low, "\tThis is CopyLocal {0} as parent item has this value", parent_copy_local); if (TryAddNewReference(tempResolvedFiles, resolved_ref)) { FindAndAddRelatedFiles(resolved_ref.TaskItem.ItemSpec, parent_copy_local); FindAndAddSatellites(resolved_ref.TaskItem.ItemSpec, parent_copy_local); } } else { //gac or tgtfmwk Log.LogMessage(MessageImportance.Low, "\tThis is CopyLocal false as it is in the gac," + "target framework directory or provided by a package."); TryAddNewReference(tempResolvedFiles, resolved_ref); } } else { Log.LogWarning("Reference '{0}' not resolved", aname); assembly_resolver.LogSearchLoggerMessages(MessageImportance.Normal); } return(resolved_ref); }
// get library and file definitions private void GetPackageAndFileDefinitions() { TaskItem item; foreach (var package in LockFile.Libraries) { var packageName = package.Name; var packageVersion = package.Version.ToNormalizedString(); string packageId = $"{packageName}/{packageVersion}"; item = new TaskItem(packageId); item.SetMetadata(MetadataKeys.Name, packageName); item.SetMetadata(MetadataKeys.Type, package.Type); item.SetMetadata(MetadataKeys.Version, packageVersion); item.SetMetadata(MetadataKeys.Path, package.Path ?? string.Empty); string resolvedPackagePath = ResolvePackagePath(package); item.SetMetadata(MetadataKeys.ResolvedPath, resolvedPackagePath ?? string.Empty); _packageDefinitions.Add(item); foreach (var file in package.Files) { if (NuGetUtils.IsPlaceholderFile(file)) { continue; } var fileKey = $"{packageId}/{file}"; var fileItem = new TaskItem(fileKey); fileItem.SetMetadata(MetadataKeys.Path, file); fileItem.SetMetadata(MetadataKeys.PackageName, packageName); fileItem.SetMetadata(MetadataKeys.PackageVersion, packageVersion); string resolvedPath = ResolveFilePath(file, resolvedPackagePath); fileItem.SetMetadata(MetadataKeys.ResolvedPath, resolvedPath ?? string.Empty); if (NuGetUtils.IsApplicableAnalyzer(file, ProjectLanguage)) { fileItem.SetMetadata(MetadataKeys.Analyzer, "true"); fileItem.SetMetadata(MetadataKeys.Type, "AnalyzerAssembly"); // get targets that contain this package var parentTargets = LockFile.Targets .Where(t => t.Libraries.Any(lib => lib.Name == package.Name)); foreach (var target in parentTargets) { var fileDepsItem = new TaskItem(fileKey); fileDepsItem.SetMetadata(MetadataKeys.ParentTarget, target.Name); // Foreign Key fileDepsItem.SetMetadata(MetadataKeys.ParentPackage, packageId); // Foreign Key _fileDependencies.Add(fileDepsItem); } } else { // get a type for the file if one is available string fileType; if (!_fileTypes.TryGetValue(fileKey, out fileType)) { fileType = "unknown"; } fileItem.SetMetadata(MetadataKeys.Type, fileType); } _fileDefinitions.Add(fileItem); } } }
private void ProcessInputFileList( ITaskItem[] inputFiles, List <ITaskItem> imageCompilationList, List <ITaskItem> symbolsCompilationList, List <ITaskItem> r2rFilesPublishList, List <ITaskItem> r2rReferenceList, List <ITaskItem> r2rCompositeReferenceList, List <ITaskItem> r2rCompositeInputList, bool hasValidDiaSymReaderLib) { if (inputFiles == null) { return; } var exclusionSet = ExcludeList == null || Crossgen2Composite ? null : new HashSet <string>(ExcludeList, StringComparer.OrdinalIgnoreCase); var compositeExclusionSet = PublishReadyToRunCompositeExclusions == null || !Crossgen2Composite ? null : new HashSet <string>(PublishReadyToRunCompositeExclusions, StringComparer.OrdinalIgnoreCase); foreach (var file in inputFiles) { var eligibility = GetInputFileEligibility(file, Crossgen2Composite, exclusionSet, compositeExclusionSet); if (eligibility.NoEligibility) { continue; } if (eligibility.IsReference) { r2rReferenceList.Add(file); } if (eligibility.IsReference && !eligibility.ReferenceHiddenFromCompositeBuild && !eligibility.Compile) { r2rCompositeReferenceList.Add(file); } if (!eligibility.Compile) { continue; } var outputR2RImageRelativePath = file.GetMetadata(MetadataKeys.RelativePath); var outputR2RImage = Path.Combine(OutputPath, outputR2RImageRelativePath); string outputPDBImage = null; string outputPDBImageRelativePath = null; string crossgen1CreatePDBCommand = null; if (EmitSymbols) { if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && hasValidDiaSymReaderLib) { outputPDBImage = Path.ChangeExtension(outputR2RImage, "ni.pdb"); outputPDBImageRelativePath = Path.ChangeExtension(outputR2RImageRelativePath, "ni.pdb"); crossgen1CreatePDBCommand = $"/CreatePDB \"{Path.GetDirectoryName(outputPDBImage)}\""; } else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) { using (FileStream fs = new FileStream(file.ItemSpec, FileMode.Open, FileAccess.Read)) { PEReader pereader = new PEReader(fs); MetadataReader mdReader = pereader.GetMetadataReader(); Guid mvid = mdReader.GetGuid(mdReader.GetModuleDefinition().Mvid); outputPDBImage = Path.ChangeExtension(outputR2RImage, "ni.{" + mvid + "}.map"); outputPDBImageRelativePath = Path.ChangeExtension(outputR2RImageRelativePath, "ni.{" + mvid + "}.map"); crossgen1CreatePDBCommand = $"/CreatePerfMap \"{Path.GetDirectoryName(outputPDBImage)}\""; } } } if (eligibility.CompileSeparately) { // This TaskItem is the IL->R2R entry, for an input assembly that needs to be compiled into a R2R image. This will be used as // an input to the ReadyToRunCompiler task TaskItem r2rCompilationEntry = new TaskItem(file); r2rCompilationEntry.SetMetadata(MetadataKeys.OutputR2RImage, outputR2RImage); if (outputPDBImage != null && ReadyToRunUseCrossgen2 && !_crossgen2IsVersion5) { r2rCompilationEntry.SetMetadata(MetadataKeys.EmitSymbols, "true"); r2rCompilationEntry.SetMetadata(MetadataKeys.OutputPDBImage, outputPDBImage); } r2rCompilationEntry.RemoveMetadata(MetadataKeys.OriginalItemSpec); imageCompilationList.Add(r2rCompilationEntry); } else if (eligibility.CompileIntoCompositeImage) { r2rCompositeInputList.Add(file); } // This TaskItem corresponds to the output R2R image. It is equivalent to the input TaskItem, only the ItemSpec for it points to the new path // for the newly created R2R image TaskItem r2rFileToPublish = new TaskItem(file); r2rFileToPublish.ItemSpec = outputR2RImage; r2rFileToPublish.RemoveMetadata(MetadataKeys.OriginalItemSpec); r2rFilesPublishList.Add(r2rFileToPublish); // Note: ReadyToRun PDB/Map files are not needed for debugging. They are only used for profiling, therefore the default behavior is to not generate them // unless an explicit PublishReadyToRunEmitSymbols flag is enabled by the app developer. There is also another way to profile that the runtime supports, which does // not rely on the native PDBs/Map files, so creating them is really an opt-in option, typically used by advanced users. // For debugging, only the IL PDBs are required. if (eligibility.CompileSeparately && outputPDBImage != null) { if (!ReadyToRunUseCrossgen2 || _crossgen2IsVersion5) { // This TaskItem is the R2R->R2RPDB entry, for a R2R image that was just created, and for which we need to create native PDBs. This will be used as // an input to the ReadyToRunCompiler task TaskItem pdbCompilationEntry = new TaskItem(file); pdbCompilationEntry.ItemSpec = outputR2RImage; pdbCompilationEntry.SetMetadata(MetadataKeys.OutputPDBImage, outputPDBImage); pdbCompilationEntry.SetMetadata(MetadataKeys.CreatePDBCommand, crossgen1CreatePDBCommand); symbolsCompilationList.Add(pdbCompilationEntry); } // This TaskItem corresponds to the output PDB image. It is equivalent to the input TaskItem, only the ItemSpec for it points to the new path // for the newly created PDB image. TaskItem r2rSymbolsFileToPublish = new TaskItem(file); r2rSymbolsFileToPublish.ItemSpec = outputPDBImage; r2rSymbolsFileToPublish.SetMetadata(MetadataKeys.RelativePath, outputPDBImageRelativePath); r2rSymbolsFileToPublish.RemoveMetadata(MetadataKeys.OriginalItemSpec); if (!IncludeSymbolsInSingleFile) { r2rSymbolsFileToPublish.SetMetadata(MetadataKeys.ExcludeFromSingleFile, "true"); } r2rFilesPublishList.Add(r2rSymbolsFileToPublish); } } if (Crossgen2Composite) { MainAssembly.SetMetadata(MetadataKeys.RelativePath, Path.GetFileName(MainAssembly.ItemSpec)); var compositeR2RImageRelativePath = MainAssembly.GetMetadata(MetadataKeys.RelativePath); compositeR2RImageRelativePath = Path.ChangeExtension(compositeR2RImageRelativePath, "r2r" + Path.GetExtension(compositeR2RImageRelativePath)); var compositeR2RImage = Path.Combine(OutputPath, compositeR2RImageRelativePath); TaskItem r2rCompilationEntry = new TaskItem(MainAssembly); r2rCompilationEntry.ItemSpec = r2rCompositeInputList[0].ItemSpec; r2rCompilationEntry.SetMetadata(MetadataKeys.OutputR2RImage, compositeR2RImage); r2rCompilationEntry.SetMetadata(MetadataKeys.CreateCompositeImage, "true"); r2rCompilationEntry.RemoveMetadata(MetadataKeys.OriginalItemSpec); if (EmitSymbols) { string compositePDBImage = null; string compositePDBRelativePath = null; if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && hasValidDiaSymReaderLib) { compositePDBImage = Path.ChangeExtension(compositeR2RImage, ".ni.pdb"); compositePDBRelativePath = Path.ChangeExtension(compositeR2RImageRelativePath, ".ni.pdb"); } else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) { compositePDBImage = Path.ChangeExtension(compositeR2RImage, ".ni.{composite}.map"); compositePDBRelativePath = Path.ChangeExtension(compositeR2RImageRelativePath, ".ni.{composite}.map"); } if (compositePDBImage != null && ReadyToRunUseCrossgen2 && !_crossgen2IsVersion5) { r2rCompilationEntry.SetMetadata(MetadataKeys.EmitSymbols, "true"); r2rCompilationEntry.SetMetadata(MetadataKeys.OutputPDBImage, compositePDBImage); // Publish composite PDB file TaskItem r2rSymbolsFileToPublish = new TaskItem(MainAssembly); r2rSymbolsFileToPublish.ItemSpec = compositePDBImage; r2rSymbolsFileToPublish.SetMetadata(MetadataKeys.RelativePath, compositePDBRelativePath); r2rSymbolsFileToPublish.RemoveMetadata(MetadataKeys.OriginalItemSpec); if (!IncludeSymbolsInSingleFile) { r2rSymbolsFileToPublish.SetMetadata(MetadataKeys.ExcludeFromSingleFile, "true"); } r2rFilesPublishList.Add(r2rSymbolsFileToPublish); } } imageCompilationList.Add(r2rCompilationEntry); // Publish it TaskItem compositeR2RFileToPublish = new TaskItem(MainAssembly); compositeR2RFileToPublish.ItemSpec = compositeR2RImage; compositeR2RFileToPublish.RemoveMetadata(MetadataKeys.OriginalItemSpec); compositeR2RFileToPublish.SetMetadata(MetadataKeys.RelativePath, compositeR2RImageRelativePath); r2rFilesPublishList.Add(compositeR2RFileToPublish); } }
/// <summary> /// Fills the provided CommandLineBuilderExtension with those switches and other information that can go into a response file. /// </summary> protected internal virtual void AddResponseFileCommands(CommandLineBuilderExtension commandLine) { // If outputAssembly is not specified, then an "/out: <name>" option won't be added to // overwrite the one resulting from the OutputAssembly member of the CompilerParameters class. // In that case, we should set the outputAssembly member based on the first source file. if ( (OutputAssembly == null) && (Sources != null) && (Sources.Length > 0) && (this.ResponseFiles == null) // The response file may already have a /out: switch in it, so don't try to be smart here. ) { try { OutputAssembly = new TaskItem(Path.GetFileNameWithoutExtension(Sources[0].ItemSpec)); } catch (ArgumentException e) { throw new ArgumentException(e.Message, "Sources"); } if (String.Compare(TargetType, "library", StringComparison.OrdinalIgnoreCase) == 0) { OutputAssembly.ItemSpec += ".dll"; } else if (String.Compare(TargetType, "module", StringComparison.OrdinalIgnoreCase) == 0) { OutputAssembly.ItemSpec += ".netmodule"; } else { OutputAssembly.ItemSpec += ".exe"; } } commandLine.AppendSwitchIfNotNull("/addmodule:", this.AddModules, ","); commandLine.AppendSwitchWithInteger("/codepage:", this._store, "CodePage"); ConfigureDebugProperties(); // The "DebugType" parameter should be processed after the "EmitDebugInformation" parameter // because it's more specific. Order matters on the command-line, and the last one wins. // /debug+ is just a shorthand for /debug:full. And /debug- is just a shorthand for /debug:none. commandLine.AppendPlusOrMinusSwitch("/debug", this._store, "EmitDebugInformation"); commandLine.AppendSwitchIfNotNull("/debug:", this.DebugType); commandLine.AppendPlusOrMinusSwitch("/delaysign", this._store, "DelaySign"); commandLine.AppendSwitchWithInteger("/filealign:", this._store, "FileAlignment"); commandLine.AppendSwitchIfNotNull("/keycontainer:", this.KeyContainer); commandLine.AppendSwitchIfNotNull("/keyfile:", this.KeyFile); // If the strings "LogicalName" or "Access" ever change, make sure to search/replace everywhere in vsproject. commandLine.AppendSwitchIfNotNull("/linkresource:", this.LinkResources, new string[] { "LogicalName", "Access" }); commandLine.AppendWhenTrue("/nologo", this._store, "NoLogo"); commandLine.AppendWhenTrue("/nowin32manifest", this._store, "NoWin32Manifest"); commandLine.AppendPlusOrMinusSwitch("/optimize", this._store, "Optimize"); commandLine.AppendSwitchIfNotNull("/out:", this.OutputAssembly); commandLine.AppendSwitchIfNotNull("/ruleset:", this.CodeAnalysisRuleSet); commandLine.AppendSwitchIfNotNull("/errorlog:", this.ErrorLog); commandLine.AppendSwitchIfNotNull("/subsystemversion:", this.SubsystemVersion); // TODO: uncomment the below line once "/reportanalyzer" switch is added to compiler. //commandLine.AppendWhenTrue("/reportanalyzer", this._store, "ReportAnalyzer"); // If the strings "LogicalName" or "Access" ever change, make sure to search/replace everywhere in vsproject. commandLine.AppendSwitchIfNotNull("/resource:", this.Resources, new string[] { "LogicalName", "Access" }); commandLine.AppendSwitchIfNotNull("/target:", this.TargetType); commandLine.AppendPlusOrMinusSwitch("/warnaserror", this._store, "TreatWarningsAsErrors"); commandLine.AppendWhenTrue("/utf8output", this._store, "Utf8Output"); commandLine.AppendSwitchIfNotNull("/win32icon:", this.Win32Icon); commandLine.AppendSwitchIfNotNull("/win32manifest:", this.Win32Manifest); // Append the analyzers. this.AddAnalyzersToCommandLine(commandLine); // Append additional files. this.AddAdditionalFilesToCommandLine(commandLine); // Append the sources. commandLine.AppendFileNamesIfNotNull(Sources, " "); }
// PUT api/task/5 public void UpdateTask(int id, [FromBody] TaskItem taskItem) { _taskService.Update(taskItem); }
public override bool Execute() { if (NativeReferences == null || NativeReferences.Length == 0) { return(!Log.HasLoggedErrors); } var embeddedResources = new List <ITaskItem> (); var nativeFrameworks = new List <ITaskItem> (); var text = new StringBuilder(); for (int i = 0; i < NativeReferences.Length; i++) { NativeReferenceKind kind; string value; value = NativeReferences[i].GetMetadata("Kind") ?? string.Empty; if (!Enum.TryParse(value, out kind)) { Log.LogError(null, null, null, NativeReferences[i].ItemSpec, 0, 0, 0, 0, MSBStrings.W0051, value); continue; } var path = NativeReferences[i].ItemSpec; var logicalName = Path.GetFileName(path); var item = new TaskItem(path); if (kind == NativeReferenceKind.Framework) { nativeFrameworks.Add(item); } else { item.SetMetadata("LogicalName", logicalName); item.SetMetadata("WithCulture", "false"); item.SetMetadata("Type", "Non-Resx"); embeddedResources.Add(item); } text.AppendFormat("[assembly: ObjCRuntime.LinkWith (\"{0}\"", logicalName); AppendLinkTargetProperty(text, NativeReferences[i]); AppendBooleanProperty(text, NativeReferences[i], "IsCxx"); AppendBooleanProperty(text, NativeReferences[i], "NeedsGccExceptionHandling"); AppendBooleanProperty(text, NativeReferences[i], "SmartLink", true); AppendBooleanProperty(text, NativeReferences[i], "ForceLoad"); AppendStringProperty(text, NativeReferences[i], "Frameworks"); AppendStringProperty(text, NativeReferences[i], "WeakFrameworks"); AppendStringProperty(text, NativeReferences[i], "LinkerFlags"); text.Append(")]"); text.AppendLine(); } bool skipLinkWithGeneration = false; string linkWithText = text.ToString(); var linkWithPath = Path.Combine(IntermediateOutputPath, "LinkWithAttributes.cs"); if (File.Exists(linkWithPath)) { string existingLinkWithText = File.ReadAllText(linkWithPath); skipLinkWithGeneration = String.Equals(existingLinkWithText, linkWithText, StringComparison.Ordinal); } if (!skipLinkWithGeneration) { Directory.CreateDirectory(Path.GetDirectoryName(linkWithPath)); File.WriteAllText(linkWithPath, linkWithText); } EmbeddedResources = embeddedResources.ToArray(); NativeFrameworks = nativeFrameworks.ToArray(); LinkWithAttributes = new TaskItem(linkWithPath); return(!Log.HasLoggedErrors); }
public TaskItemWrapper(TaskItem inner, LoadTaskItemDelegate load) { _load = load; _inner = inner; }
/// <summary> /// </summary> /// <param name="id"></param> /// <param name="taskItem"></param> /// <returns> /// </returns> private ReminderTask GetTaskFromItem(string id, TaskItem taskItem) { var reminderTask = new ReminderTask(taskItem.EntryID,taskItem.Subject,taskItem.Body, taskItem.DueDate); reminderTask.IsCompleted = taskItem.Complete; reminderTask.CreatedOn = taskItem.CreationTime; reminderTask.UpdatedOn = taskItem.LastModificationTime; reminderTask.CompletedOn = taskItem.DateCompleted; reminderTask.StartDate = taskItem.StartDate; reminderTask.StatusEnum = taskItem.GetTaskStatus(); return reminderTask; }
private void DisposeInner() { Marshal.FinalReleaseComObject(Inner); _inner = null; }
internal ITaskItem ConvertToITaskItem (Expression transform, ExpressionOptions options) { TaskItem taskItem; taskItem = new TaskItem (GetItemSpecFromTransform (transform, options), evaluatedMetadata); return taskItem; }
protected override void ExecuteCore() { // Perf optimization: If there are no FrameworkReference items, then don't do anything // (This means that if you don't have any direct framework references, you won't get any transitive ones either if (FrameworkReferences == null || FrameworkReferences.Length == 0) { return; } var normalizedTargetFrameworkVersion = NormalizeVersion(new Version(TargetFrameworkVersion)); var knownFrameworkReferencesForTargetFramework = KnownFrameworkReferences.Select(item => new KnownFrameworkReference(item)) .Where(kfr => kfr.TargetFramework.Framework.Equals(TargetFrameworkIdentifier, StringComparison.OrdinalIgnoreCase) && NormalizeVersion(kfr.TargetFramework.Version) == normalizedTargetFrameworkVersion) .ToList(); var frameworkReferenceMap = FrameworkReferences.ToDictionary(fr => fr.ItemSpec, StringComparer.OrdinalIgnoreCase); List <ITaskItem> packagesToDownload = new List <ITaskItem>(); List <ITaskItem> runtimeFrameworks = new List <ITaskItem>(); List <ITaskItem> targetingPacks = new List <ITaskItem>(); List <ITaskItem> runtimePacks = new List <ITaskItem>(); List <ITaskItem> unavailableRuntimePacks = new List <ITaskItem>(); HashSet <string> unrecognizedRuntimeIdentifiers = new HashSet <string>(StringComparer.OrdinalIgnoreCase); bool windowsOnlyErrorLogged = false; foreach (var knownFrameworkReference in knownFrameworkReferencesForTargetFramework) { frameworkReferenceMap.TryGetValue(knownFrameworkReference.Name, out ITaskItem frameworkReference); // Handle Windows-only frameworks on non-Windows platforms if (knownFrameworkReference.IsWindowsOnly && !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { // It is an error to reference the framework from non-Windows if (!windowsOnlyErrorLogged && frameworkReference != null) { Log.LogError(Strings.WindowsDesktopFrameworkRequiresWindows); windowsOnlyErrorLogged = true; } // Ignore (and don't download) this known framework reference as it requires Windows continue; } List <string> preferredPackages = new List <string>(); preferredPackages.Add(knownFrameworkReference.TargetingPackName); var knownFrameworkReferenceRuntimePackRuntimeIdentifiers = knownFrameworkReference.RuntimePackRuntimeIdentifiers.Split(';'); foreach (var runtimeIdentifier in knownFrameworkReferenceRuntimePackRuntimeIdentifiers) { foreach (var runtimePackNamePattern in knownFrameworkReference.RuntimePackNamePatterns.Split(';')) { string runtimePackName = runtimePackNamePattern.Replace("**RID**", runtimeIdentifier); preferredPackages.Add(runtimePackName); } } // Get the path of the targeting pack in the targeting pack root (e.g. dotnet/ref) TaskItem targetingPack = new TaskItem(knownFrameworkReference.Name); targetingPack.SetMetadata(MetadataKeys.PackageName, knownFrameworkReference.TargetingPackName); targetingPack.SetMetadata(MetadataKeys.PackageConflictPreferredPackages, string.Join(";", preferredPackages)); string targetingPackVersion = null; if (frameworkReference != null) { // Allow targeting pack version to be overridden via metadata on FrameworkReference targetingPackVersion = frameworkReference.GetMetadata("TargetingPackVersion"); } if (string.IsNullOrEmpty(targetingPackVersion)) { targetingPackVersion = knownFrameworkReference.TargetingPackVersion; } targetingPack.SetMetadata(MetadataKeys.PackageVersion, targetingPackVersion); targetingPack.SetMetadata("TargetingPackFormat", knownFrameworkReference.TargetingPackFormat); targetingPack.SetMetadata("TargetFramework", knownFrameworkReference.TargetFramework.GetShortFolderName()); targetingPack.SetMetadata(MetadataKeys.RuntimeFrameworkName, knownFrameworkReference.RuntimeFrameworkName); targetingPack.SetMetadata(MetadataKeys.RuntimePackRuntimeIdentifiers, knownFrameworkReference.RuntimePackRuntimeIdentifiers); if (!string.IsNullOrEmpty(knownFrameworkReference.Profile)) { targetingPack.SetMetadata("Profile", knownFrameworkReference.Profile); } string targetingPackPath = null; if (!string.IsNullOrEmpty(TargetingPackRoot)) { targetingPackPath = Path.Combine(TargetingPackRoot, knownFrameworkReference.TargetingPackName, targetingPackVersion); } if (targetingPackPath != null && Directory.Exists(targetingPackPath)) { // Use targeting pack from packs folder targetingPack.SetMetadata(MetadataKeys.PackageDirectory, targetingPackPath); targetingPack.SetMetadata(MetadataKeys.Path, targetingPackPath); } else { if (EnableTargetingPackDownload) { // Download targeting pack TaskItem packageToDownload = new TaskItem(knownFrameworkReference.TargetingPackName); packageToDownload.SetMetadata(MetadataKeys.Version, targetingPackVersion); packagesToDownload.Add(packageToDownload); } } targetingPacks.Add(targetingPack); var runtimeFrameworkVersion = GetRuntimeFrameworkVersion( frameworkReference, knownFrameworkReference, out string runtimePackVersion); string isTrimmable = null; if (frameworkReference != null) { // Allow IsTrimmable to be overridden via metadata on FrameworkReference isTrimmable = frameworkReference.GetMetadata(MetadataKeys.IsTrimmable); } if (string.IsNullOrEmpty(isTrimmable)) { isTrimmable = knownFrameworkReference.IsTrimmable; } bool processedPrimaryRuntimeIdentifier = false; if ((SelfContained || ReadyToRunEnabled) && !string.IsNullOrEmpty(RuntimeIdentifier) && !string.IsNullOrEmpty(knownFrameworkReference.RuntimePackNamePatterns)) { ProcessRuntimeIdentifier(RuntimeIdentifier, knownFrameworkReference, runtimePackVersion, unrecognizedRuntimeIdentifiers, unavailableRuntimePacks, runtimePacks, packagesToDownload, isTrimmable); processedPrimaryRuntimeIdentifier = true; } if (RuntimeIdentifiers != null) { foreach (var runtimeIdentifier in RuntimeIdentifiers) { if (processedPrimaryRuntimeIdentifier && runtimeIdentifier == this.RuntimeIdentifier) { // We've already processed this RID continue; } // Pass in null for the runtimePacks list, as for these runtime identifiers we only want to // download the runtime packs, but not use the assets from them ProcessRuntimeIdentifier(runtimeIdentifier, knownFrameworkReference, runtimePackVersion, unrecognizedRuntimeIdentifiers, unavailableRuntimePacks, runtimePacks: null, packagesToDownload, isTrimmable); } } if (!string.IsNullOrEmpty(knownFrameworkReference.RuntimeFrameworkName)) { TaskItem runtimeFramework = new TaskItem(knownFrameworkReference.RuntimeFrameworkName); runtimeFramework.SetMetadata(MetadataKeys.Version, runtimeFrameworkVersion); runtimeFramework.SetMetadata(MetadataKeys.FrameworkName, knownFrameworkReference.Name); runtimeFrameworks.Add(runtimeFramework); } } if (packagesToDownload.Any()) { PackagesToDownload = packagesToDownload.ToArray(); } if (runtimeFrameworks.Any()) { RuntimeFrameworks = runtimeFrameworks.ToArray(); } if (targetingPacks.Any()) { TargetingPacks = targetingPacks.ToArray(); } if (runtimePacks.Any()) { RuntimePacks = runtimePacks.ToArray(); } if (unavailableRuntimePacks.Any()) { UnavailableRuntimePacks = unavailableRuntimePacks.ToArray(); } }
internal ITaskItem[] ConvertToITaskItemArray (Project project, ExpressionOptions options) { if (converting) { // found ref to @this while trying to ConvertToITaskItemArray // for @this! ITaskItem []items = new ITaskItem [1]; items [0] = new TaskItem (FinalValue); return items; } converting = true; try { Expression exp = new Expression (); // in non-evaluation phase, properties are always expanded exp.Parse (FinalValue, ParseOptions.Split | (options == ExpressionOptions.ExpandItemRefs ? ParseOptions.AllowItems : ParseOptions.None)); return (ITaskItem[]) exp.ConvertTo (project, typeof (ITaskItem[]), options); } finally { converting = false; } }
public async Task UpdateTaskItem(TaskItem taskItem) { _db.Entry(taskItem).State = EntityState.Modified; await SaveAsync(); }