/// <summary>
/// Method to download the issues for the given project
/// </summary>
/// <param name="source">the external data source to use</param>
/// <param name="project">the project to download the issues for</param>
/// <returns>the list of issues corresponding to the given project</returns>
private static IList <IssueInfo> DownloadIssuesForProject(IExternalSource source, ProjectInfo project)
{
// get parameter and action
var parameters = new DataSourceParameter()
{
ProjectId = project.Id, StatusId = -1
};
Action <int, int> action =
(i, overall) =>
{
if (Globals.ThisAddIn == null)
{
return;
}
Globals.ThisAddIn.SyncState.Status = string.Format(
"Lade Issues für neues Projekt {0} ({1}/{2})",
project.Name,
Math.Min(i, overall),
overall);
};
try
{
// load data and add the issues. Note that we load all issues here
var newIssuesOfProject = source.GetTotalIssueInfoList(parameters, action);
return(newIssuesOfProject);
}
catch (Exception exception)
{
Log.Error(string.Format("Error while loading project {0}", project.Name), exception);
return(new List <IssueInfo>());
}
}
private List <DataSourceParameter> ProcessParametersText(string parameters)
{
List <DataSourceParameter> dsParams = new List <DataSourceParameter>();
if (string.IsNullOrWhiteSpace(parameters))
{
return(dsParams);
}
foreach (var line in parameters.Split("\n", StringSplitOptions.RemoveEmptyEntries))
{
var parts = line.Replace("\r", "").Split(",", StringSplitOptions.RemoveEmptyEntries);
if (parts.Count() != 3)
{
throw new Exception("Invalid parameter description: " + line);
}
DataSourceParameter dsPar = new DataSourceParameter();
dsPar.Name = parts[0].Trim();
dsPar.Type = parts[1].ToLowerInvariant().Trim();
if (string.IsNullOrWhiteSpace(dsPar.Type))
{
throw new Exception("Invalid parameter type in: " + line);
}
dsPar.Value = parts[2].Trim();
dsParams.Add(dsPar);
}
return(dsParams);
}
/// <summary>
/// Downloads all redmine projects and update the cache with the new data
/// </summary>
/// <param name="source">the data source to use</param>
/// <returns>The projects that are downloaded from redmine.</returns>
public static ProjectLists GetCurrentProjectsAndUpdateCache(IExternalSource source)
{
if (Globals.ThisAddIn != null)
{
Globals.ThisAddIn.SyncState.Status = "Lade Projekte...";
}
var parameters = new DataSourceParameter();
var projects = source.GetTotalProjectList(
parameters,
(cur, total) =>
{
if (Globals.ThisAddIn != null)
{
Globals.ThisAddIn.SyncState.Status = string.Format("Lade Projekte ({0}/{1})", Math.Min(cur, total), total);
}
}).Where(p => p.Id.HasValue).ToDictionary(p => p.Id.Value, p => p);
// Get the known projects from localcache
var knownProjects = LocalCache.ReadObject(LocalCache.KnownProjects, new List <ProjectInfo>()) as List <ProjectInfo> ?? new List <ProjectInfo>();
// Find those projects which are new
var newProjects = projects.Values.Except(knownProjects).ToList();
// Write all currently known projects
LocalCache.WriteObject(LocalCache.KnownProjects, projects.Values.ToList());
return(new ProjectLists()
{
AllProjects = projects, NewProjects = newProjects
});
}
/// <summary>
/// Method to get the list of all activity infos
/// </summary>
/// <param name="source">the external data source</param>
/// <returns>the activities</returns>
public static Dictionary <int, ActivityInfo> GetActivityInfos(IExternalSource source)
{
var parameters = new DataSourceParameter()
{
UseLimit = false
};
var activities = source.GetTotalActivityInfoList(parameters).ToDictionary(act => act.Id.Value, act => act);
return(activities);
}
public EqlParameter ConvertDataSourceParameterToEqlParameter(DataSourceParameter dsParameter)
{
var parName = dsParameter.Name;
if (!parName.StartsWith("@"))
{
parName = "@" + parName;
}
return(new EqlParameter(parName, GetDataSourceParameterValue(dsParameter)));
}
public void TestParameterConversionNoParameterGiven()
{
// arrange
var manager = new RedmineManagerInstance(Url, ApiKey);
var parameter = new DataSourceParameter();
// act
var queryParameter = manager.GetParametersForQuery(parameter);
// assert
Assert.That(queryParameter, Is.Not.Null);
Assert.That(queryParameter.Count, Is.EqualTo(0));
}
public void TestDownloadProjectInfos()
{
// arrange
var manager = new RedmineManagerInstance(Url, ApiKey);
var parameters = new DataSourceParameter();
// act
var projects = manager.GetTotalProjectList(parameters);
// assert
Assert.That(projects, Is.Not.Null);
Assert.That(projects.Count, Is.GreaterThan(0));
}
public void TestGetAllIssuesAssignedToMe()
{
var manager = new RedmineManagerInstance(Url, ApiKey);
var parameters = new DataSourceParameter()
{
AssignedToUserId = -1
};
// act
var issues = manager.GetIssueInfoList(parameters);
// assert
Assert.That(issues.Count, Is.GreaterThan(0));
}
public void TestDownloadIssueInfosWithProjectFilterForExistingProject()
{
// arrange
var manager = new RedmineManagerInstance(Url, ApiKey);
var parameters = new DataSourceParameter()
{
ProjectId = 333
};
// act
var issues = manager.GetTotalIssueInfoList(parameters);
// assert
Assert.That(issues, Is.Not.Null);
Assert.That(issues.Count, Is.GreaterThan(0));
}
/// <summary>
/// Method to get the parameter to use for the download of the issues
/// </summary>
/// <param name="issuesKnown">flag indicating if up to now issues are known already</param>
/// <returns>the parameter to use for the query</returns>
private static DataSourceParameter GetDataSourceParameterForDownloadOfIssues(bool issuesKnown)
{
// get new issues since that date minus one
var lastSync = Settings.Default.LastIssueSyncDate;
var parameters = new DataSourceParameter()
{
UseLimit = true, StatusId = -1
};
if (issuesKnown)
{
Log.Info(string.Format("Last Sync Date set to {0:d}", lastSync.Date.AddDays(-2)));
parameters.UpdateStartDateTime = lastSync.Date.AddDays(-2);
}
return(parameters);
}
public void TestParameterConversionNoParameterButProjectIdSet(int projectIdToSet, string expectedValue)
{
// arrange
var manager = new RedmineManagerInstance(Url, ApiKey);
var parameter = new DataSourceParameter()
{
ProjectId = projectIdToSet
};
// act
var queryParameter = manager.GetParametersForQuery(parameter);
// assert
Assert.That(queryParameter, Is.Not.Null);
Assert.That(queryParameter.Count, Is.EqualTo(1));
Assert.That(queryParameter["project_id"], Is.EqualTo(expectedValue));
}
public void TestParameterConversionNoParameterButSpentTimeSet()
{
// arrange
var manager = new RedmineManagerInstance(Url, ApiKey);
var parameter = new DataSourceParameter()
{
SpentDateTimeTuple = Tuple.Create(new DateTime(2016, 1, 3), new DateTime(2017, 7, 26))
};
// act
var queryParameter = manager.GetParametersForQuery(parameter);
// assert
Assert.That(queryParameter, Is.Not.Null);
Assert.That(queryParameter.Count, Is.EqualTo(1));
Assert.That(queryParameter["spent_on"], Is.EqualTo("><2016-01-03|2017-07-26"));
}
public void TestParameterConversionNoParameterButUpdateStartTimeSet()
{
// arrange
var manager = new RedmineManagerInstance(Url, ApiKey);
var parameter = new DataSourceParameter()
{
UpdateStartDateTime = new DateTime(2017, 2, 8)
};
// act
var queryParameter = manager.GetParametersForQuery(parameter);
// assert
Assert.That(queryParameter, Is.Not.Null);
Assert.That(queryParameter.Count, Is.EqualTo(1));
Assert.That(queryParameter["updated_on"], Is.EqualTo(">=2017-02-08"));
}
public void TestDownloadIssueInfosWithLimitViaBoolLimit()
{
// arrange
var manager = new RedmineManagerInstance(Url, ApiKey, 1);
var parameters = new DataSourceParameter()
{
UseLimit = true
};
// act
var issues = manager.GetIssueInfoList(parameters);
// assert
Assert.That(issues, Is.Not.Null);
Assert.That(issues.Count, Is.GreaterThan(0));
Assert.That(issues.Count, Is.LessThanOrEqualTo(1));
}
protected DataSourceParameters GetArgs(string query)
{
using (var connection = GetOpenedConnection())
{
var queryParameters = new DataSourceParameters();
using var reader = connection.GetReader(query);
while (reader.Read())
{
var args = new DataSourceParameter
{
Name = reader.GetValue(0)?.ToString(),
Type = reader.GetValue(1)?.ToString()
};
queryParameters.Parameters.Add(args);
}
return(queryParameters);
}
}
private dynamic ParsePostData()
{
var formData = HttpContext.Request.Form;
dynamic rec = new ExpandoObject();
ValidationException validation = new ValidationException();
DataSourceManager dsMan = new DataSourceManager();
DataSourceBase dataSource = null;
rec.IsDeleteAction = false;
//handle delete
if (formData.ContainsKey("action") && formData["action"] == "delete")
{
rec.IsDeleteAction = true;
rec.PageDataSourceId = (Guid?)null;
if (formData.ContainsKey("page_datasource_id") && !string.IsNullOrWhiteSpace(formData["page_datasource_id"]))
{
Guid pageDataSourceId;
if (Guid.TryParse(formData["page_datasource_id"], out pageDataSourceId))
{
rec.PageDataSourceId = pageDataSourceId;
}
else
{
validation.AddError("page_datasource_id", "Specified page data source id is not in valid GUID format.");
}
}
validation.CheckAndThrow();
return(rec);
}
//continue with create or update parse
rec.PageDataSourceId = (Guid?)null;
if (formData.ContainsKey("page_datasource_id") && !string.IsNullOrWhiteSpace(formData["page_datasource_id"]))
{
Guid pageDataSourceId;
if (Guid.TryParse(formData["page_datasource_id"], out pageDataSourceId))
{
rec.PageDataSourceId = pageDataSourceId;
}
else
{
validation.AddError("page_datasource_id", "Specified page data source id is not in valid GUID format.");
}
}
if (formData.ContainsKey("page_id") && !string.IsNullOrWhiteSpace(formData["page_id"]))
{
Guid pageId;
if (Guid.TryParse(formData["page_id"], out pageId))
{
rec.PageId = pageId;
}
else
{
validation.AddError("page_id", "Specified page id is not in valid GUID format.");
}
}
else
{
validation.AddError("page_id", "Page id is not specified.");
}
if (formData.ContainsKey("datasource_id") && !string.IsNullOrWhiteSpace(formData["datasource_id"]))
{
Guid datasourceId;
if (Guid.TryParse(formData["datasource_id"], out datasourceId))
{
rec.DataSourceId = datasourceId;
dataSource = dsMan.Get(datasourceId);
if (dataSource == null)
{
validation.AddError("datasource_id", "Specified datasource id is not found in database.");
}
}
else
{
validation.AddError("datasource_id", "Specified datasource id is not in valid GUID format.");
}
}
else
{
validation.AddError("datasource_id", "Datasource id is not specified.");
}
if (formData.ContainsKey("page_datasource_name") && !string.IsNullOrWhiteSpace(formData["page_datasource_name"]))
{
rec.Name = formData["page_datasource_name"];
}
else
{
validation.AddError("page_datasource_name", "Page datasource name is not specified.");
}
validation.CheckAndThrow();
List <DataSourceParameter> parameters = new List <DataSourceParameter>();
foreach (var par in dataSource.Parameters)
{
var htmlKey = "@_" + par.Name;
if (formData.Keys.Contains(htmlKey) && !string.IsNullOrWhiteSpace(formData[htmlKey]))
{
DataSourceParameter parameter = new DataSourceParameter();
parameter.Name = par.Name;
parameter.Type = par.Type;
parameter.Value = formData[htmlKey];
parameters.Add(parameter);
}
}
rec.Parameters = parameters;
return(rec);
}
public object GetDataSourceParameterValue(DataSourceParameter dsParameter)
{
switch (dsParameter.Type.ToLower())
{
case "guid":
{
if (string.IsNullOrWhiteSpace(dsParameter.Value))
{
return(null);
}
if (dsParameter.Value.ToLowerInvariant() == "null")
{
return(null);
}
if (dsParameter.Value.ToLowerInvariant() == "guid.empty")
{
return(Guid.Empty);
}
if (Guid.TryParse(dsParameter.Value, out Guid value))
{
return(value);
}
throw new Exception($"Invalid Guid value for parameter: " + dsParameter.Name);
}
case "int":
{
if (string.IsNullOrWhiteSpace(dsParameter.Value))
{
return(null);
}
if (Int32.TryParse(dsParameter.Value, out int value))
{
return(value);
}
if (dsParameter.Value.ToLowerInvariant() == "null")
{
return(null);
}
throw new Exception($"Invalid int value for parameter: " + dsParameter.Name);
}
case "decimal":
{
if (string.IsNullOrWhiteSpace(dsParameter.Value))
{
return(null);
}
if (Decimal.TryParse(dsParameter.Value, out decimal value))
{
return(value);
}
throw new Exception($"Invalid decimal value for parameter: " + dsParameter.Name);
}
case "date":
{
if (string.IsNullOrWhiteSpace(dsParameter.Value))
{
return(null);
}
if (dsParameter.Value.ToLowerInvariant() == "null")
{
return(null);
}
if (dsParameter.Value.ToLowerInvariant() == "now")
{
return(DateTime.Now);
}
if (dsParameter.Value.ToLowerInvariant() == "utc_now")
{
return(DateTime.UtcNow);
}
if (DateTime.TryParse(dsParameter.Value, out DateTime value))
{
return(value);
}
throw new Exception($"Invalid datetime value for parameter: " + dsParameter.Name);
}
case "text":
{
if (dsParameter.Value.ToLowerInvariant() == "null")
{
return(null);
}
if (dsParameter.Value.ToLowerInvariant() == "string.empty")
{
return(String.Empty);
}
return(dsParameter.Value);
}
case "bool":
{
if (dsParameter.Value.ToLowerInvariant() == "null")
{
return(null);
}
if (dsParameter.Value.ToLowerInvariant() == "true")
{
return(true);
}
if (dsParameter.Value.ToLowerInvariant() == "false")
{
return(false);
}
throw new Exception($"Invalid boolean value for parameter: " + dsParameter.Name);
}
default:
throw new Exception($"Invalid parameter type '{dsParameter.Type}' for '{dsParameter.Name}'");
}
}
