public static void PerformAction(string verb, string fileName)
{
switch (verb)
{
case "open":
DesktopManager.Instance.IsOverlayOpen = false;
Shell.StartProcess(fileName);
return;
case "openwith":
DesktopManager.Instance.IsOverlayOpen = false;
Shell.ShowOpenWithDialog(fileName);
return;
case "delete":
string displayName = Shell.GetDisplayName(fileName);
bool? deleteChoice = CairoMessage.ShowOkCancel(string.Format(Localization.DisplayString.sDesktop_DeleteInfo, displayName), Localization.DisplayString.sDesktop_DeleteTitle, "Resources/cairoIcon.png", Localization.DisplayString.sInterface_Delete, Localization.DisplayString.sInterface_Cancel);
if (deleteChoice.HasValue && deleteChoice.Value)
{
Shell.SendToRecycleBin(fileName);
}
return;
case "properties":
Shell.ShowFileProperties(fileName);
DesktopManager.Instance.IsOverlayOpen = false;
return;
case "copy":
StringCollection scPath = new StringCollection();
scPath.Add(fileName);
System.Windows.Forms.Clipboard.SetFileDropList(scPath);
return;
case "addStack":
StacksManager.Instance.AddLocation(fileName);
return;
case "removeStack":
StacksManager.Instance.StackLocations.Remove(new SystemDirectory(fileName, _dispatcher));
return;
case "openWithShell":
FolderHelper.OpenWithShell(fileName);
break;
case "personalize" when Shell.IsCairoRunningAsShell:
CairoSettingsWindow.Instance.Show();
CairoSettingsWindow.Instance.Activate();
CairoSettingsWindow.Instance.TabDesktop.IsSelected = true;
break;
case "personalize":
Shell.StartProcess("Rundll32.exe", "shell32.dll,Control_RunDLL desk.cpl,,2");
break;
case "displaySettings":
Shell.StartProcess("Rundll32.exe", "shell32.dll,Control_RunDLL desk.cpl,,3");
break;
default:
Shell.StartProcess(fileName, "", verb);
break;
}
}
void LoadToMemory(Guid fileIdSpecified)
{
var connection = DatabaseConnection.Current;
using (var command = new SqlCommand("Create table #tempSimilarFile ([Id] uniqueidentifier, [File1Id] uniqueidentifier, [File2Id] uniqueidentifier, [DifferenceDegree] real, [IgnoredMode] int)", connection))
{
command.ExecuteNonQuery();
}
var insertCommand = "insert into #tempSimilarFile Select [Id],[File1Id],[File2Id],[DifferenceDegree],[IgnoredMode] from [SimilarFile] where [DifferenceDegree]<=@DifferenceDegree";
if (!IncludesDisconnected.IsPresent) //skip while loading to memory
{
insertCommand += " and [IgnoredMode]<>2";
}
using (var command = new SqlCommand(insertCommand, connection)
{
CommandTimeout = 180
})
{
command.Parameters.Add(new SqlParameter("@DifferenceDegree", System.Data.SqlDbType.Real)
{
Value = DifferenceDegree
});
if (fileIdSpecified != Guid.Empty)
{
command.CommandText += " and ([File1Id] = @FileId or [File2Id] = @FileId)";
command.Parameters.Add(new SqlParameter("@FileId", System.Data.SqlDbType.UniqueIdentifier)
{
Value = fileIdSpecified
});
}
command.ExecuteNonQuery();
}
using (var command = new SqlCommand("Select [Id],[File1Id],[File2Id],[DifferenceDegree],[IgnoredMode] from #tempSimilarFile", connection)
{
CommandTimeout = 180
})
{
using (var reader = command.ExecuteReader(System.Data.CommandBehavior.SequentialAccess))
{
while (reader.Read())
{
ImageStoreSimilarFile line = new ImageStoreSimilarFile((Guid)reader[0], (Guid)reader[1], (Guid)reader[2], (float)reader[3])
{
IgnoredModeCode = (int)reader[4]
};
allRecords.Add(line.Id, line);
if (!fileToRecords.TryGetValue(line.File1Id, out var records))
{
records = new List <Guid>();
fileToRecords.Add(line.File1Id, records);
}
records.Add(line.Id);
if (!fileToRecords.TryGetValue(line.File2Id, out records))
{
records = new List <Guid>();
fileToRecords.Add(line.File2Id, records);
}
records.Add(line.Id);
}
}
}
using (var command = new SqlCommand("Create table #tempSimilarFileId ([Id] uniqueidentifier)", connection))
{
command.ExecuteNonQuery();
}
using (var command = new SqlCommand("insert into #tempSimilarFileId select distinct * from (select [File1Id] from #tempSimilarFile union select [File2Id] from #tempSimilarFile) IdTable", connection)
{
CommandTimeout = 180
})
{
command.ExecuteNonQuery();
}
using (var command = new SqlCommand("drop table #tempSimilarFile", connection))
{
command.ExecuteNonQuery();
}
using (var command = new SqlCommand("Select [Id],[FolderId],[Path],[FileName],[ExtensionId],[ImageHash],[Sha1Hash],[FileSize],[FileState],[ImageComparedThreshold] from [File] Where [Id] in (select [id] from #tempSimilarFileId)", connection)
{
CommandTimeout = 180
})
{
using (var reader = command.ExecuteReader(System.Data.CommandBehavior.SequentialAccess))
{
ImageStoreFile result;
while (reader.Read())
{
result = new ImageStoreFile((Guid)reader[0], (Guid)reader[1], (string)reader[2], (string)reader[3], (Guid)reader[4])
{
ImageHash = DBNullableReader.ConvertFromReferenceType <byte[]>(reader[5]),
Sha1Hash = DBNullableReader.ConvertFromReferenceType <byte[]>(reader[6]),
FileSize = (int)reader[7],
FileStateCode = (int)reader[8],
ImageComparedThreshold = (float)reader[9]
};
allFiles.Add(result.Id, result);
allFileInfo.Add(result.Id, new FileInfo());
}
reader.Close();
}
}
using (var command = new SqlCommand("drop table #tempSimilarFileId", connection))
{
command.ExecuteNonQuery();
}
if (allFiles.Count > 0)
{
allFolders = new Dictionary <Guid, ImageStoreFolder>();
allExtensionNames = new Dictionary <Guid, string>();
foreach (var folder in FolderHelper.GetAllFolders())
{
allFolders.Add(folder.Id, folder);
}
foreach (var extension in ExtensionHelper.GetAllExtensions())
{
allExtensionNames.Add(extension.Id, extension.Extension);
}
Parallel.ForEach(allFiles.Values, i => allFileInfo[i.Id].SetData(i, allFolders[i.FolderId], allExtensionNames[i.ExtensionId]));
}
}
private void OpenMyDocs(object sender, RoutedEventArgs e)
{
FolderHelper.OpenLocation(KnownFolders.GetPath(KnownFolder.Documents));
}
public override void Refresh(bool recursive)
{
if (IsInvalid)
{
return;
}
base.Refresh(recursive);
// item icon
if (Parent is DirectoryNode)
{
insideClasspath = (Parent as DirectoryNode).insideClasspath;
insideLibrarypath = (Parent as DirectoryNode).insideLibrarypath;
}
string colorId = "ProjectTreeView.ForeColor";
if (project != null)
{
if (project.IsPathHidden(BackingPath))
{
ImageIndex = Icons.HiddenFolder.Index;
}
else if (insideClasspath == null && project.IsClassPath(BackingPath))
{
insideClasspath = this;
ImageIndex = Icons.ClasspathFolder.Index;
}
else if (insideClasspath != null && project.IsCompileTarget(BackingPath))
{
ImageIndex = Icons.FolderCompile.Index;
}
else if (insideLibrarypath == null && project.IsLibraryAsset(BackingPath))
{
LibraryAsset asset = project.GetAsset(BackingPath);
if (asset.SwfMode == SwfAssetMode.ExternalLibrary)
{
colorId = "ProjectTreeView.ExternalLibraryTextColor";
}
else if (asset.SwfMode == SwfAssetMode.Library)
{
colorId = "ProjectTreeView.LibraryTextColor";
}
else if (asset.SwfMode == SwfAssetMode.IncludedLibrary)
{
colorId = "ProjectTreeView.IncludedLibraryTextColor";
}
insideLibrarypath = this;
ImageIndex = Icons.LibrarypathFolder.Index;
}
else
{
ImageIndex = Icons.Folder.Index;
}
}
else
{
ImageIndex = Icons.Folder.Index;
}
SelectedImageIndex = ImageIndex;
Color textColor = PluginBase.MainForm.GetThemeColor(colorId);
if (colorId != "ProjectTreeView.ForeColor" && textColor == Color.Empty)
{
textColor = SystemColors.Highlight;
}
if (textColor != Color.Empty)
{
ForeColorRequest = textColor;
}
else
{
ForeColorRequest = SystemColors.ControlText;
}
// make the plus/minus sign correct
// TODO: Check if this works ok!
bool empty = !Directory.Exists(BackingPath) || FolderHelper.IsDirectoryEmpty(BackingPath);
if (!empty)
{
// we want the plus sign because we have *something* in here
if (Nodes.Count == 0)
{
Nodes.Add(new PlaceholderNode(Path.Combine(BackingPath, "placeholder")));
}
// we're already expanded, so refresh our children
if (IsExpanded || Path.GetDirectoryName(Tree.PathToSelect) == BackingPath)
{
PopulateChildNodes(recursive);
}
else
{
dirty = true; // refresh on demand
}
}
else
{
// we just became empty!
if (Nodes.Count > 0)
{
PopulateChildNodes(recursive);
}
}
NotifyRefresh();
}
public virtual ActionResult EditImage(string folderName, string uuid, [System.Web.Mvc.Bind(Prefix = "Crop")] ImageCropModel cropModel,
[System.Web.Mvc.Bind(Prefix = "Scale")] ImageScaleModel scaleModel, string rotateTypes, string @return)
{
var mediaFolder = FolderHelper.Parse <MediaFolder>(Repository.Current, folderName);
var mediaContent = mediaFolder.CreateQuery().WhereEquals("UUID", uuid).FirstOrDefault();
JsonResultData data = new JsonResultData(ModelState);
Stream targetStream = new MemoryStream();
MemoryStream resizedImage = new MemoryStream();
Stream imageStream = new MemoryStream();
int width = 0, height = 0;
try
{
ImageFormat imageFormat = ImageTools.ConvertToImageFormat(Path.GetExtension(mediaContent.PhysicalPath));
imageStream = RotateImage(rotateTypes, mediaContent.PhysicalPath, imageFormat);
if (cropModel != null && cropModel.X.HasValue && cropModel.Width.Value > 0 && cropModel.Height.Value > 0)
{
ImageTools.CropImage(imageStream, targetStream, imageFormat, cropModel.X.Value, cropModel.Y.Value, cropModel.Width.Value, cropModel.Height.Value);
targetStream.Position = 0;
}
else
{
targetStream = imageStream;
}
if (scaleModel != null && scaleModel.Height.HasValue && scaleModel.Width.HasValue)
{
ImageTools.ResizeImage(targetStream, resizedImage, imageFormat, scaleModel.Width.Value, scaleModel.Height.Value, scaleModel.PreserveAspectRatio, scaleModel.Quality ?? 80);
resizedImage.Position = 0;
targetStream = resizedImage;
}
Image image = Image.FromStream(targetStream);
width = image.Width;
height = image.Height;
targetStream.Position = 0;
ServiceFactory.MediaContentManager.Update(Repository.Current, mediaFolder, uuid, mediaContent.FileName, targetStream, User.Identity.Name);
image.Dispose();
targetStream.Close();
//data.ClosePopup = true;
//data.AddMessage("The image has been changed.".Localize());
}
catch (Exception e)
{
data.AddException(e);
}
finally
{
if (targetStream != null)
{
targetStream.Close();
targetStream.Dispose();
targetStream = null;
}
if (resizedImage != null)
{
resizedImage.Close();
resizedImage.Dispose();
resizedImage = null;
}
if (imageStream != null)
{
imageStream.Close();
imageStream.Dispose();
imageStream = null;
}
}
data.Model = new { Width = width, Height = height };
data.RedirectToOpener = false;
data.ReloadPage = true;
return(Json(data));
}
public void UseDefaultFolderForJournals()
{
FolderHelper.UseDefaultFolder();
this.journalManager.JournalFolder = FolderHelper.JournalsFolder;
}
public virtual ActionResult SelectTextContent(string siteName, string folderName, string selected, int?page, int?pageSize, string search,
string sortField = null, string sortDir = null)
{
var site = SiteHelper.Parse(siteName);
var repository = site.GetRepository();
var textFolder = (TextFolder)(FolderHelper.Parse <TextFolder>(repository, folderName).AsActual());
var singleChoice = string.Equals("True", Request.RequestContext.GetRequestValue("SingleChoice"), StringComparison.OrdinalIgnoreCase);
Schema schema = new Schema(repository, textFolder.SchemaName).AsActual();
SchemaPath schemaPath = new SchemaPath(schema);
ViewData["Folder"] = textFolder;
ViewData["Schema"] = schema;
ViewData["Template"] = textFolder.GetFormTemplate(FormType.Selectable);
//ViewData["WhereClause"] = whereClause;
IEnumerable <TextFolder> childFolders = new TextFolder[0];
//Skip the child folders on the embedded folder grid.
if (!page.HasValue || page.Value <= 1)
{
childFolders = ServiceFactory.TextFolderManager.ChildFoldersWithSameSchema(textFolder).Select(it => it.AsActual());
}
var query = textFolder.CreateQuery();
if (!string.IsNullOrEmpty(sortField))
{
query = query.SortBy(sortField, sortDir);
}
else
{
query = query.DefaultOrder();
}
bool showTreeStyle = schema.IsTreeStyle;
if (showTreeStyle)
{
query = query.Where(new OrElseExpression(new WhereEqualsExpression(null, "ParentUUID", null), new WhereEqualsExpression(null, "ParentUUID", "")));
}
if (!string.IsNullOrEmpty(search))
{
IWhereExpression exp = new FalseExpression();
foreach (var item in schema.Columns.Where(it => it.ShowInGrid))
{
exp = new OrElseExpression(exp, (new WhereContainsExpression(null, item.Name, search)));
}
if (exp != null)
{
query = query.Where(exp);
}
showTreeStyle = false;
}
var contents = query.ToPageList(page ?? 1, pageSize ?? textFolder.PageSize, textFolder.EnablePaging.HasValue ? textFolder.EnablePaging.Value : true);
SelectableViewModel viewModel = new SelectableViewModel()
{
ShowTreeStyle = showTreeStyle, ChildFolders = childFolders, Contents = contents, SingleChoice = singleChoice
};
if (Request.IsAjaxRequest())
{
return(PartialView("", viewModel));
}
else
{
IEnumerable <TextContent> selectedContents = new TextContent[0];
if (!string.IsNullOrEmpty(selected))
{
string[] selectedArr = selected.Split(',');
IContentQuery <TextContent> selectedQuery = textFolder.CreateQuery().DefaultOrder();
foreach (var userKey in selectedArr)
{
selectedQuery = selectedQuery.Or((IWhereExpression)textFolder.CreateQuery().DefaultOrder().WhereEquals("UUID", userKey).Expression);
}
selectedContents = selectedQuery;
}
viewModel.Selected = selectedContents;
}
return(View(viewModel));
}
public static string GetFolderName(FileType type)
{
return(FolderHelper.GetFolderName(type));
}
public virtual bool IsValid(Repository repository)
{
var folder = FolderHelper.Parse <TextFolder>(repository, FolderName);
return(folder.AsActual() != null);
}
/// <summary>
/// Launches the FileManager specified in the application Settings object to the specified directory.
/// </summary>
/// <param name="directoryPath">Directory to open.</param>
private void openDir(string directoryPath, bool openWithShell)
{
if ((!openWithShell && !FolderHelper.OpenLocation(directoryPath)) || (openWithShell && !FolderHelper.OpenWithShell(directoryPath)))
{
CairoMessage.Show(Localization.DisplayString.sError_FileNotFoundInfo, Localization.DisplayString.sError_OhNo, MessageBoxButton.OK, MessageBoxImage.Error);
}
}
public void RunScript(
string dslFolder,
string scriptFolder,
string scriptname,
Dictionary <string, object> args,
IAzureDevOpsProvider iAzureDevOpsProvider,
IEmailProvider iEmailProvider,
IEventDataProvider iEventData)
{
if (scriptname == null)
{
throw new ArgumentNullException("scriptname");
}
else
{
if (string.IsNullOrEmpty(scriptFolder))
{
scriptFolder = FolderHelper.GetRootedPath("~/");
}
else
{
scriptFolder = FolderHelper.GetRootedPath(scriptFolder);
}
if (File.Exists(scriptname) == false)
{
// we have not been given a resolvable file name, so try appending the base path
scriptname = Path.Combine(scriptFolder, scriptname);
if (File.Exists(scriptname) == false)
{
this.logger.Error(string.Format("DslProcessor: DslProcessor cannot find script:{0}", scriptname));
return;
}
}
}
if (iEventData == null)
{
throw new ArgumentNullException("iEventData");
}
if (iAzureDevOpsProvider == null)
{
throw new ArgumentNullException("iAzureDevOpsProvider");
}
if (iEmailProvider == null)
{
throw new ArgumentNullException("iEmailProvider");
}
if (string.IsNullOrEmpty(dslFolder))
{
dslFolder = FolderHelper.GetRootedPath("~/");
}
else
{
dslFolder = FolderHelper.GetRootedPath(dslFolder);
}
// load the DSL wrapper class via MEF
//An aggregate catalog that combines multiple catalogs
var catalog = new AggregateCatalog();
//Adds all the parts found in the same assembly as the Program class
if (Directory.Exists(dslFolder))
{
this.logger.Info(
string.Format("DslProcessor: DslProcessor loading DSL from {0}", Path.GetFullPath(dslFolder)));
catalog.Catalogs.Add(new DirectoryCatalog(dslFolder));
}
else
{
this.logger.Error(
string.Format("DslProcessor: DslProcessor cannot find DSL folder {0}", Path.GetFullPath(dslFolder)));
return;
}
try
{
//Create the CompositionContainer with the parts in the catalog
var container = new CompositionContainer(catalog);
container.ComposeParts(this);
}
catch (CompositionException compositionException)
{
this.logger.Error(string.Format("DsLProcessor: {0}", compositionException.Message));
return;
}
catch (ReflectionTypeLoadException ex)
{
this.logger.Error(string.Format("DsLProcessor: {0}", ex.Message));
StringBuilder sb = new StringBuilder();
foreach (Exception exSub in ex.LoaderExceptions)
{
sb.AppendLine(exSub.Message);
FileNotFoundException exFileNotFound = exSub as FileNotFoundException;
if (exFileNotFound != null)
{
if (!string.IsNullOrEmpty(exFileNotFound.FusionLog))
{
sb.AppendLine("Fusion Log:");
sb.AppendLine(exFileNotFound.FusionLog);
}
}
sb.AppendLine();
}
this.logger.Error(string.Format("DslProcessor: {0}", sb.ToString()));
return;
}
this.logger.Info(
string.Format("DslProcessor: DslProcessor found {0} DSL libraries", this.dslLibraries.Count()));
if (this.dslLibraries.Any())
{
// create the engine
var engine = IronPython.Hosting.Python.CreateEngine(args);
var objOps = engine.Operations;
var scope = engine.CreateScope();
// inject the providers
foreach (var item in this.dslLibraries)
{
item.EmailProvider = iEmailProvider;
item.TfsProvider = iAzureDevOpsProvider;
item.EventData = iEventData;
item.ScriptFolder = scriptFolder;
// Read in the methods
foreach (string memberName in objOps.GetMemberNames(item))
{
scope.SetVariable(memberName, objOps.GetMember(item, memberName));
}
}
if (this.redirectScriptEngineOutputtoLogging == true)
{
// redirect the console out opf the script to the nLog
engine.Runtime.IO.SetOutput(
new ConsoleRedirectStreamToNlog(LogLevel.Info, "PythonScriptConsole"),
System.Text.Encoding.ASCII);
engine.Runtime.IO.SetErrorOutput(
new ConsoleRedirectStreamToNlog(LogLevel.Error, "PythonScriptError"),
System.Text.Encoding.ASCII);
}
else
{
// this is only used in tests where the console is visible or being cpatured in another manner
engine.Runtime.IO.RedirectToConsole();
}
// run the script
this.logger.Info(string.Format(
"DslProcessor: DslProcessor running script:{0}",
scriptname));
var script = engine.CreateScriptSourceFromFile(scriptname);
script.Execute(scope);
}
else
{
this.logger.Error(
string.Format("DslProcessor: DslProcessor cannot find DSL libraries in folder {0}", Path.GetFullPath(dslFolder)));
return;
}
}
public CodeMetricsViewModel(RubberduckParserState state, ICodeMetricsAnalyst analyst, FolderHelper folderHelper, IVBE vbe)
{
_state = state;
_analyst = analyst;
_folderHelper = folderHelper;
_state.StateChanged += OnStateChanged;
_vbe = vbe;
}
public FolderInfoModel GetContactFolderInfo(Guid folderId)
{
return(FolderHelper.GetFolderInfo("ContactFolder", folderId, UserConnection));
}
public UserFolderProcessor(FolderHelper folderHelper)
{
_folderHelper = folderHelper;
}
private void OpenRecycleBin(object sender, RoutedEventArgs e)
{
FolderHelper.OpenLocation("::{645FF040-5081-101B-9F08-00AA002F954E}");
}
/// <summary>
/// 실행파일 위치폴더값 리턴
/// </summary>
/// <returns>실행파일 위치폴더값</returns>
public static string GetApplicationPath()
{
return(FolderHelper.GetModuleFileDirectory());
}
public void UseMyFolderForJournals(string path)
{
FolderHelper.UseUserFolder(path);
this.journalManager.JournalFolder = FolderHelper.JournalsFolder;
}
private void OpenMyMusic(object sender, RoutedEventArgs e)
{
FolderHelper.OpenLocation(KnownFolders.GetPath(KnownFolder.Music));
}
private void SaveAssembly(string assemblyName, byte[] assemblyBytes)
{
var path = FolderHelper.CreateFolder(_beimingForceConfig.AppLibPath);
FolderHelper.CreateFile(Path.Combine(path, assemblyName), assemblyBytes);
}
private void OpenMyVideos(object sender, RoutedEventArgs e)
{
FolderHelper.OpenLocation(KnownFolders.GetPath(KnownFolder.Videos));
}
public virtual ActionResult GetFolderInfo(string folderPath)
{
if (string.IsNullOrWhiteSpace(folderPath))
{
return null;
}
var folder = Kooboo.CMS.Content.Models.IPersistableExtensions.AsActual(new TextFolder(Repository, FolderHelper.SplitFullName(folderPath)));
if (folder == null)
{
return null;
}
var subfolders = ContentService.ServiceFactory.TextFolderManager.ChildFolders(folder);
var schema = ContentService.ServiceFactory.SchemaManager.Get(Repository, folder.SchemaName);
var folderInfo = new
{
Folder = folder,
Schema = schema,
//ContentList = folder.CreateQuery(),
FolderList = subfolders,
CategoryFolders = folder.Categories == null ? (new List<TextFolder>()) : folder.Categories.Select(o => FolderHelper.Parse<TextFolder>(Repository, o.FolderName))
};
return Json(folderInfo);
}
private void OpenDownloads(object sender, RoutedEventArgs e)
{
FolderHelper.OpenLocation(KnownFolders.GetPath(KnownFolder.Downloads));
}
private void btnOpenLogsFolder_OnClick(object sender, RoutedEventArgs e)
{
FolderHelper.OpenWithShell("%localappdata%\\Cairo_Development_Team\\Logs");
}
private void OpenMyComputer(object sender, RoutedEventArgs e)
{
FolderHelper.OpenLocation("::{20D04FE0-3AEA-1069-A2D8-08002B30309D}");
}
public virtual ActionResult GetFolderInfo(string folderPath)
{
if (string.IsNullOrWhiteSpace(folderPath))
{
return(null);
}
var folder = (new TextFolder(Repository.Current, FolderHelper.SplitFullName(folderPath))).AsActual();
if (folder == null)
{
return(null);
}
var subfolders = ContentService.ServiceFactory.TextFolderManager.ChildFolders(folder);
var schema = ContentService.ServiceFactory.SchemaManager.Get(Repository.Current, folder.SchemaName);
var folderInfo = new
{
Folder = folder,
Schema = schema,
ContentList = folder.CreateQuery(),
FolderList = subfolders,
CategoryFolders = folder.Categories == null ? (new List <TextFolder>()) : folder.Categories.Select(o => FolderHelper.Parse <TextFolder>(Repository.Current, o.FolderName))
};
return(Json(folderInfo));
}
private void OpenUserFolder(object sender, RoutedEventArgs e)
{
FolderHelper.OpenLocation(Environment.GetEnvironmentVariable("USERPROFILE"));
}
[Authorize] // Require some form of authentication
public HttpResponseMessage Post([FromBody] JObject jsondata)
{
try
{
if (ConfigHelper.ParseOrDefault(Microsoft.Azure.CloudConfigurationManager.GetSetting("LogEventsToFile")) == true)
{
var logPath = ConfigHelper.GetLoggingPath();
logger.Info(string.Format("Post: Event being logged to [{0}]", logPath));
LoggingHelper.DumpEventToDisk(jsondata, logPath);
}
var dataProvider = new Providers.JsonDataProvider(jsondata);
var uri = dataProvider.GetServerUrl();
var locationpat = ConfigHelper.GetPersonalAccessToken(uri);
logger.Info($"Post: Using a {uri}");
if (string.IsNullOrEmpty(locationpat.Item2) == false)
{
logger.Info($"Post: Using a PAT token and obtained from {locationpat.Item1}");
this.iAzureDevOpsProvider = new Providers.AzureDevOpsProvider(uri, locationpat.Item2);
}
else
{
logger.Info(string.Format("Post: Using default credentials and url {0}", uri));
this.iAzureDevOpsProvider = new Providers.AzureDevOpsProvider(uri);
}
// work out the event type
var eventType = dataProvider.GetEventType();
// work out the subscription ID
var subscriptionID = dataProvider.GetSubsriptionID();
string[] argItems = null;
switch (eventType)
{
case "workitem.updated":
case "workitem.created":
case "workitem.deleted":
case "workitem.restored":
case "workitem.commented":
var workItemId = dataProvider.GetWorkItemDetails().Id;
if (workItemId > 0)
{
argItems = new[] { eventType, workItemId.ToString() };
logger.Info(
string.Format("Post: {1} Event being processed for WI:{0}", workItemId, eventType));
}
else
{
logger.Error(
string.Format("Post: {0} Event cannot find workitem ID", eventType));
return(new HttpResponseMessage(HttpStatusCode.BadRequest));
}
break;
case "build.complete":
var buildDetails = dataProvider.GetBuildDetails();
argItems = new[] { eventType, buildDetails.Id.ToString() };
logger.Info(string.Format(
"Post: Event being processed for Build:{0}",
buildDetails.BuildUri));
break;
case "ms.vss-release.deployment-approval-completed-event":
case "ms.vss-release.deployment-approval-pending-event":
case "ms.vss-release.deployment-completed-event":
case "ms.vss-release.deployment-started-event":
case "ms.vss-release.release-abandoned-event":
case "ms.vss-release.release-created-event":
var releaseDetails = dataProvider.GetReleaseDetails();
argItems = new[] { eventType, releaseDetails.Id.ToString() };
logger.Info(string.Format(
"Post: Event being processed for Release:{0}",
releaseDetails.Id));
break;
case "tfvc.checkin":
var checkInDetails = dataProvider.GetCheckInDetails();
argItems = new[] { eventType, checkInDetails.Changeset.ToString() };
logger.Info(
string.Format(
"Post: Event being processed for Checkin:{0}",
checkInDetails.Changeset));
break;
case "message.posted":
var messagePostDetails = dataProvider.GetMessagePostDetails();
argItems = new[] { eventType, messagePostDetails.PostRoomId.ToString() };
logger.Info(
string.Format(
"Post: Event being processed for Meesage Post in Room:{0}",
messagePostDetails.PostRoomId));
break;
case "git.push":
var pushDetails = dataProvider.GetPushDetails();
argItems = new[] { eventType, pushDetails.Repo, pushDetails.PushId.ToString() };
logger.Info(
string.Format(
"Post: Event being processed for Push:{0}",
pushDetails.PushId));
break;
case "git.pullrequest.created":
case "git.pullrequest.merged":
case "git.pullrequest.updated":
var pullDetails = dataProvider.GetPullDetails();
argItems = new[] { eventType, pullDetails.Repo, pullDetails.PullId.ToString() };
logger.Info(
string.Format(
"Post: Event being processed for Pull:{0}",
pullDetails.PullId));
break;
default:
logger.Info(string.Format("Post: Unhandled event cannot processed:{0}", eventType));
return(new HttpResponseMessage(HttpStatusCode.BadRequest));
}
var args = new Dictionary <string, object>
{
{ "Arguments", argItems },
};
var engine = new AzureDevOpsEventsProcessor.Dsl.DslProcessor(redirectScriptEngineOutputtoLogging);
engine.RunScript(
this.dslFolder,
this.scriptFolder,
FolderHelper.GetScriptName(
eventType,
subscriptionID,
this.scriptFile,
this.useSubscriptionID),
args,
this.iAzureDevOpsProvider,
this.iEmailProvider,
dataProvider);
return(new HttpResponseMessage(HttpStatusCode.OK));
}
catch (Exception ex)
{
// using a global exception catch to make sure we don't block any threads
LoggingHelper.DumpException(logger, ex);
return(new HttpResponseMessage(HttpStatusCode.BadRequest));
}
}
private void OpenProgramFiles(object sender, RoutedEventArgs e)
{
FolderHelper.OpenLocation(Environment.GetEnvironmentVariable("ProgramFiles"));
}
private void OpenMyPics(object sender, RoutedEventArgs e)
{
FolderHelper.OpenLocation(KnownFolders.GetPath(KnownFolder.Pictures));
}
public TreePath GetPath(ITabularObject item)
{
if (item == null)
{
return(TreePath.Empty);
}
var stack = new List <object>();
stack.Add(Model);
if (item is PartitionViewTable || item is Partition)
{
stack.Add(Model.Groups.Partitions);
if (item is Partition)
{
stack.Add((item as Partition).Table.PartitionViewTable);
}
stack.Add(item);
return(new TreePath(stack.ToArray()));
}
if (Options.HasFlag(LogicalTreeOptions.AllObjectTypes) && item != Model)
{
// If "Show all object types" is enabled, we need to add the "group" of the item to the stack,
// to get the complete path. The group can be determined from the type of object:
switch (item.ObjectType)
{
case ObjectType.Culture: stack.Add(Model.Groups.Translations); break;
case ObjectType.Role: stack.Add(Model.Groups.Roles); break;
case ObjectType.Perspective: stack.Add(Model.Groups.Perspectives); break;
case ObjectType.DataSource: stack.Add(Model.Groups.DataSources); break;
case ObjectType.Relationship: stack.Add(Model.Groups.Relationships); break;
default:
// All other object types should appear in the "Tables" group:
stack.Add(Model.Groups.Tables); break;
}
}
if (item is Table)
{
stack.Add(item);
}
else if (item is ITabularTableObject)
{
stack.Add((item as ITabularTableObject).Table);
var level = item as Level;
if (level != null)
{
item = level.Hierarchy;
}
if (item is IDetailObject && Options.HasFlag(LogicalTreeOptions.DisplayFolders))
{
var dfo = item as IDetailObject;
var pathBits = dfo.Table.Name.ConcatPath(dfo.GetDisplayFolder(Culture)).Split('\\');
var folderPath = dfo.Table.Name;
for (var i = 1; i < pathBits.Length; i++)
{
folderPath = folderPath.ConcatPath(pathBits[i]);
if (!FolderCache.ContainsKey(folderPath))
{
Folder.CreateFolder(dfo.Table, FolderHelper.PathFromFullPath(folderPath));
}
stack.Add(FolderCache[folderPath]);
}
}
stack.Add(item);
if (level != null)
{
stack.Add(level);
}
}
return(new TreePath(stack.ToArray()));
}
