private XElement WhereContainsOrIncludes([NotNull] ComparisonModel comparison)
{
if (comparison.Field.Type != FieldRefType.KnownMember)
{
throw new NotSupportedException("Unsupported FieldRefType value");
}
var memberRef = (MemberRefModel)comparison.Field;
var metaField = GetMetaField(memberRef);
var isLookup = metaField.TypeAsString.StartsWith("User") || metaField.TypeAsString.StartsWith("Lookup");
if (comparison.ComparisonOperator == ComparisonOperator.ContainsOrIncludes)
{
return(WhereComparison(isLookup ? ComparisonOperator.Includes : ComparisonOperator.Contains,
metaField,
comparison.Value,
comparison.IsValueConverted));
}
if (isLookup)
{
return(WhereComparison(ComparisonOperator.NotIncludes, metaField, comparison.Value,
comparison.IsValueConverted));
}
throw new NotSupportedException("Cannot negate Contains operation for non-lookup fields");
}
private void OnComparisonContextChanged()
{
ChartLabel[] GetLabels()
{
return(ComparisonRecords.Select(record => GetChartLabel(record.WrappedRecordInfo)).ToArray());
}
void SetLabels(ChartLabel[] labels)
{
ComparisonRowChartLabels = labels.Select(label => GetHasUniqueGameNames() ? label.Context : $"{label.GameName}{Environment.NewLine}{label.Context}").Reverse().ToArray();
if (IsContextLegendActive)
{
if (ComparisonModel.Series.Count == ComparisonRecords.Count)
{
for (int i = 0; i < ComparisonRecords.Count; i++)
{
ComparisonModel.Series[i].Title = labels[i].Context;
}
}
}
}
if (ComparisonModel == null)
{
InitializePlotModel();
}
SetLabels(GetLabels());
ComparisonModel.InvalidatePlot(true);
}
public void RemoveAllComparisonItems(bool manageVisibility = true, bool resetSortMode = false)
{
if (resetSortMode)
{
_comparisonColorManager.FreeAllColors();
}
ComparisonRecords.Clear();
UpdateCharts();
if (resetSortMode)
{
IsSortModeAscending = false;
}
if (manageVisibility)
{
HasComparisonItems = false;
}
// Manage game name header
HasUniqueGameNames = false;
CurrentGameName = string.Empty;
RemainingRecordingTime = "0.0 s";
UpdateRangeSliderParameter();
ComparisonModel.InvalidatePlot(true);
}
public override void ViewDidAppear(bool animated)
{
Console.WriteLine("HomeListViewController ViewDidAppear");
base.ViewDidAppear(animated);
if (_prepareForRestore != null)
{
FadeOutTable(_prepareForRestore);
_prepareForRestore = null;
return;
}
if (!_tableView.Opaque)
{
FadeInTable();
return;
}
if (_comparisonToAdd != null)
{
_tableView.AddComparison(_comparisonToAdd);
_comparisonToAdd = null;
}
if (_comparisonToReposition.HasValue)
{
_tableView.RepositionRowForComparison(_comparisonToReposition.Value);
_comparisonToReposition = null;
}
else
{
_tableView.DeselectSelectedRow();
}
}
/// <summary>
/// Business layer login for GetComparisonbyId Method
/// </summary>
/// <param name="Id"></param>
/// <returns></returns>
#region GetComparisonbyId
public Response <ComparisonModel> GetComparisonbyId(int Id)
{
try
{
Response <ComparisonModel> response = new Response <ComparisonModel>();
ComparisonModel model = new ComparisonModel();
model = this.quantityMeasurementRL.DeleteComparisonById(Id);
if (model is null)
{
response.Success = false;
response.Message = "No such comparison exists.";
}
else
{
response.Success = true;
response.Message = "Here is the requested comparison";
response.Data.Add(model);
}
return(response);
}
catch (Exception exception)
{
throw new Exception(exception.Message);
}
}
public IActionResult DeleteComparison([FromRoute] int Id)
{
try
{
//Throw Custom Exception For Invalid Id Field.
if (Id <= 0)
{
return(BadRequest(new { Success = false, Message = QuantityException.ExceptionType.INVALID_FIELD_EXCEPTION }));
}
//Calling DeleteCmparison From BL.
ComparisonModel comparison = this.quantityMeasurementBL.DeleteComparison(Id);
//Returning Response.
if (comparison != null)
{
return(Ok(new { Success = true, Message = "Comparisons Data Deleted Successfully", Data = comparison }));
}
else
{
return(Ok(new { Success = false, Message = "Conversions Data Deletion Failed", Data = comparison }));
}
}
catch (Exception exception)
{
return(BadRequest(new { Success = false, message = exception.Message }));
}
}
public IActionResult Compare([FromBody] ComparisonModel comparison)
{
try
{
//Throw Custom Exception For Null Field.
if (comparison == null)
{
return(BadRequest(new { Success = false, message = QuantityException.ExceptionType.NULL_FIELD_EXCEPTION }));
}
//Calling Add Comparison From BL.
ComparisonModel comparison1 = quantityMeasurementBL.AddComparison(comparison);
//Returning Response.
if (comparison.Result != null)
{
return(Ok(new { Success = true, Message = "Comparison Successful", Data = comparison1 }));
}
else
{
return(Ok(new { Success = false, Message = "Comparison Failed", Data = comparison1 }));
}
}
catch (Exception exception)
{
return(BadRequest(new { Success = false, message = exception.Message }));
}
}
public static int SaveComparison(ComparisonModel comparison)
{
if (comparison.Id != 0)
{
throw new ArgumentException("Comparison with non-zero id cannot be saved.");
}
var commandText = "insert into Comparison (UnitTypeId, UnitId, Name, CheapestComparableId) values (@UnitTypeId, @UnitId, @Name, @CheapestComparableId);";
commandText += "select last_insert_rowid();";
var parameters = new Dictionary <string, object>();
parameters.Add("@UnitTypeId", comparison.UnitTypeId);
parameters.Add("@Name", comparison.Name);
parameters.Add("@UnitId", comparison.UnitId);
parameters.Add("@CheapestComparableId", comparison.CheapestComparableId);
int newId = 0;
SqlConnection.ReaderWithCommand(commandText, parameters, (reader) => {
newId = reader.Read() ? reader.GetInt32(0) : 0;
});
return(newId);
}
/// <summary>
/// Business layer logic for comparison Method
/// </summary>
/// <param name="quantity"></param>
/// <returns></returns>
#region Comparison
public Response <ComparisonModel> Comparison(ComparisonModel quantity)
{
try
{
Response <ComparisonModel> response = new Response <ComparisonModel>();
ComparisonModel model = new ComparisonModel();
model = quantityMeasurementRL.Comparison(quantity);
if (model.Result != null)
{
response.Success = true;
response.Message = "Here are comparison results";
response.Data.Add(model);
}
else
{
response.Success = false;
response.Message = "Invalid units used. Please use valid Units";
}
return(response);
}
catch (Exception exception)
{
throw new Exception(exception.Message);
}
}
public void ReloadOnAppeared()
{
_comparison = DataService.GetComparison(_comparison.Id);
Title = _comparison.Name;
_reloadOnAppeared = true;
_tableView.Opaque = false;
_tableView.Alpha = 0;
}
/// <summary>
/// Function For Converting To Base Unit.
/// </summary>
/// <param name="comparison"></param>
/// <returns></returns>
public ComparisonModel ConvertToBaseUnit(ComparisonModel comparison)
{
try
{
//Checking If Data Is In Base Unit.
if (comparison.Value_One_Unit == Unit.Inch.ToString() && comparison.Value_Two_Unit == Unit.Inch.ToString() ||
comparison.Value_One_Unit == Unit.Gram.ToString() && comparison.Value_Two_Unit == Unit.Gram.ToString() ||
comparison.Value_One_Unit == Unit.Millilitre.ToString() && comparison.Value_Two_Unit == Unit.Millilitre.ToString() ||
comparison.Value_One_Unit == Unit.Fahrenheit.ToString() && comparison.Value_Two_Unit == Unit.Fahrenheit.ToString())
{
return(comparison);
}
//Creating QuantityModel Instances For Base Unit Conversions.
QuantityModel quantityOne = new QuantityModel();
QuantityModel quantityTwo = new QuantityModel();
quantityOne.Value = comparison.Value_One;
quantityTwo.Value = comparison.Value_Two;
//Setting Operation Type.
quantityOne.OperationType = SetOperationType(comparison.Value_One_Unit);
quantityTwo.OperationType = SetOperationType(comparison.Value_Two_Unit);
//If Both Quantity Instance Unit Are Not Base Units Then Perform Conversion.
if (quantityOne.OperationType != "BaseUnit" && quantityTwo.OperationType != "BaseUnit")
{
quantityOne.Result = Calculate(quantityOne);
quantityTwo.Result = Calculate(quantityTwo);
comparison.Value_One = quantityOne.Result;
comparison.Value_Two = quantityTwo.Result;
comparison.Value_One_Unit = SetBaseUnit(quantityOne);
comparison.Value_Two_Unit = SetBaseUnit(quantityTwo);
}
//If First Quantity Instance is in Base Unit Than Perform Conversion On Second Instance.
else if (quantityOne.OperationType == "BaseUnit" && quantityTwo.OperationType != "BaseUnit")
{
quantityTwo.Result = Calculate(quantityTwo);
comparison.Value_Two = quantityTwo.Result;
comparison.Value_Two_Unit = SetBaseUnit(quantityTwo);
}
//If Second Quantity Instance is in Base Unit Than Perform Conversion On First Instance.
else if (quantityOne.OperationType != "BaseUnit" && quantityTwo.OperationType == "BaseUnit")
{
quantityOne.Result = Calculate(quantityOne);
comparison.Value_One = quantityOne.Result;
comparison.Value_One_Unit = SetBaseUnit(quantityOne);
}
return(comparison);
}
catch (Exception exception)
{
throw exception;
}
}
/// <summary>
/// Generic send email, using fluentemail and razor templates
/// </summary>
/// <param name="subject"></param>
/// <param name="comparison"></param>
/// <param name="urlCount"></param>
public async Task SendEmail(string subject, ComparisonModel comparison, int urlCount)
{
var emailTemplate = urlCount > 0 ? "Scrape.cshtml" : "Comparison.cshtml";
var currentPath = Directory.GetCurrentDirectory();
if (!File.Exists(Path.Combine(currentPath, "EmailTemplates", emailTemplate)))
{
var relativePath = Path.Combine(currentPath, @"..\..\..", "EmailTemplates");
currentPath = Path.GetFullPath(relativePath);
}
else
{
currentPath = Path.Combine(currentPath, "EmailTemplates");
}
var templatePath = Path.Combine(currentPath, emailTemplate);
var model = new EmailModel()
{
FilesAdded = comparison.FilesAdded?.ToList() ?? new List <string>(),
FilesRemoved = comparison.FilesRemoved?.ToList() ?? new List <string>(),
LinesAddedToLatest = comparison.LinesAddedToLatest?.ToList() ?? new List <string>(),
LinesRemovedFromOriginal = comparison.LinesRemovedFromOriginal?.ToList() ?? new List <string>(),
DateTime = DateTime.Now,
RootUrl = _config.RootUrl,
Urls = urlCount
};
try
{
var email = await _fluentEmail.Create()
.SetFrom(_config.FromEmail)
.To(_config.ToEmail)
.Subject(subject)
.UsingTemplateFromFile(templatePath, model, true)
.SendAsync().ConfigureAwait(false);
if (email.Successful)
{
if (_config.ConsoleLogging)
{
Console.WriteLine("");
Console.WriteLine("Web scraper successfully sent email!");
}
}
}
catch (Exception e)
{
Console.WriteLine("");
Console.WriteLine("Sending email failed, please ensure appsettings.json is configured correctly.");
Console.WriteLine("");
Console.WriteLine($"Error message: {e}");
Console.WriteLine("");
Console.WriteLine("Please return to exit...");
Console.ReadLine();
}
}
private void UpdateAxesMinMax(bool invalidatePlot)
{
if (ComparisonRecords == null || !ComparisonRecords.Any())
{
return;
}
var xAxis = ComparisonModel.GetAxisOrDefault("xAxis", null);
var yAxis = ComparisonModel.GetAxisOrDefault("yAxis", null);
if (xAxis == null || yAxis == null)
{
return;
}
double xMin = 0;
double xMax = 0;
double yMin = 0;
double yMax = 0;
double startTime = FirstSeconds;
double endTime = _maxRecordingTime - LastSeconds;
var sessionParallelQuery = ComparisonRecords.Select(record => record.WrappedRecordInfo.Session).AsParallel();
xMin = sessionParallelQuery.Min(session =>
{
return(session.GetFrametimePointsTimeWindow(startTime, endTime).First().X);
});
xMax = sessionParallelQuery.Max(session =>
{
return(session.GetFrametimePointsTimeWindow(startTime, endTime).Last().X);
});
yMin = sessionParallelQuery.Min(session =>
{
return(session.GetFrametimePointsTimeWindow(startTime, endTime).Min(pnt => pnt.Y));;
});
yMax = sessionParallelQuery.Max(session =>
{
return(session.GetFrametimePointsTimeWindow(startTime, endTime).Max(pnt => pnt.Y));
});
xAxis.Minimum = xMin;
xAxis.Maximum = xMax;
yAxis.Minimum = yMin - (yMax - yMin) / 6;
yAxis.Maximum = yMax + (yMax - yMin) / 6;
if (invalidatePlot)
{
ComparisonModel.InvalidatePlot(true);
}
}
public void Reset(ComparisonModel comparison)
{
Comparison = comparison;
Comparables = DataService.GetComparables(Comparison.Id).OrderBy(c => c.GetPricePerBaseUnit(comparison.UnitId)).ToList();
SetScrollAndSelection();
UnitMap = (from u in DataService.GetUnits(Comparison.UnitTypeId)
select u).ToDictionary(u => u.Id, u => u);
Unit = UnitMap[Comparison.UnitId];
ReloadData();
}
public ComparisonLineupTableView(ComparisonModel comparison, RectangleF frame, UITableViewStyle style) : base(frame, style)
{
Reset(comparison);
_source = new ComparisonLineupTableViewSource(this);
_source.OnComparableSelected += (sender, args) =>
{
OnComparableSelected.Fire(this, EventArgs.Empty);
};
Source = _source;
}
/// <summary>
/// Method to take a 2 values and thier untis and compare
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
#region Comparison
public ComparisonModel Comparison(ComparisonModel model)
{
bool isUnitOneValid = Enum.TryParse <Unit>(model.ValueOneUnit, true, out Unit unitOne);
bool isUnitTwoValid = Enum.TryParse <Unit>(model.ValueTwoUnit, true, out Unit unitTwo);
if (isUnitOneValid && isUnitTwoValid)
{
try
{
var param = new SqlParameter[] {
new SqlParameter()
{
ParameterName = "@inputFirstId",
SqlDbType = SqlDbType.Int,
Direction = System.Data.ParameterDirection.Input,
Value = (int)unitOne
},
new SqlParameter()
{
ParameterName = "@inputfirstValue",
SqlDbType = SqlDbType.Float,
Direction = ParameterDirection.Input,
Value = model.ValueOne
},
new SqlParameter()
{
ParameterName = "@inputSecondId",
SqlDbType = SqlDbType.Int,
Direction = ParameterDirection.Input,
Value = (int)unitTwo
},
new SqlParameter()
{
ParameterName = "@inputSecondValue",
SqlDbType = SqlDbType.Float,
Direction = ParameterDirection.Input,
Value = model.ValueTwo
}
};
ComparisonModel output = dBContext.Comparisons.FromSql("[dbo].[spCompare] @inputFirstId, @inputfirstValue, @inputSecondId, @inputSecondValue", param).FirstOrDefault();
dBContext.SaveChanges();
return(output);
}
catch (Exception exception)
{
throw new Exception(exception.Message);
}
}
else
{
return(model);
}
}
/// <summary>
/// Function to get Sppecific Comparison Details.
/// </summary>
/// <param name="Id"></param>
/// <returns></returns>
public ComparisonModel GetComparison(int Id)
{
try
{
ComparisonModel comparison = dBContext.Comparisons.Find(Id);
return(comparison);
}
catch (Exception exception)
{
throw exception;
}
}
/// <summary>
/// Method to return a specific comparison provided it's Id
/// </summary>
/// <param name="Id"></param>
/// <returns></returns>
#region GetComparisonbyId
public ComparisonModel GetComparisonbyId(int Id)
{
try
{
ComparisonModel quantity = dBContext.Comparisons.Find(Id);
return(quantity);
}
catch (Exception exception)
{
throw new Exception(exception.Message);
}
}
public static bool UpdateComparison(ComparisonModel comparison)
{
var commandText = "update Comparison set UnitTypeId=@UnitTypeId, UnitId=@UnitId, CheapestComparableId=@CheapestComparableId, Name=@Name where Id=@Id;";
var parameters = new Dictionary <string, object>();
parameters.Add("@UnitTypeId", comparison.UnitTypeId);
parameters.Add("@Name", comparison.Name);
parameters.Add("@UnitId", comparison.UnitId);
parameters.Add("@Id", comparison.Id);
parameters.Add("@CheapestComparableId", comparison.CheapestComparableId);
return(SqlConnection.ExecuteNonQuery(commandText, parameters) > 0);
}
/// <summary>
/// Function To Add Comparison Detail to Database.
/// </summary>
/// <param name="comparison"></param>
/// <returns></returns>
public ComparisonModel AddComparison(ComparisonModel comparison)
{
try
{
dBContext.Comparisons.Add(comparison);
dBContext.SaveChanges();
return(comparison);
}
catch (Exception exception)
{
throw exception;
}
}
public void Default()
{
var factory = new MutexTokenFactory();
var model = new ComparisonModel(factory.GetTokenWrapperEnumerable(defaultTokenSet),
new [] {
new SourceEntityData("stud1", "assignment1", defaultTokenSet, "bla"),
new SourceEntityData("stud2", "assignment1", new[] { "CASE", "DECREMENT" }, "bla2")
}, factory);
model.Calculate();
Assert.AreEqual(100, model.MaximumSimilarity);
}
/// <summary>
/// Function To Add Comparison.
/// </summary>
/// <param name="comparison"></param>
/// <returns></returns>
public ComparisonModel AddComparison(ComparisonModel comparison)
{
try
{
comparison.Result = Compare(comparison);
if (comparison.Result != null)
{
return(this.quantityMeasurementRL.AddComparison(comparison));
}
return(comparison);
}
catch (Exception exception)
{
throw exception;
}
}
/// <summary>
/// Functionn To Delete Specific Comparison Detail.
/// </summary>
/// <param name="Id"></param>
/// <returns></returns>
public ComparisonModel DeleteComparison(int Id)
{
try
{
ComparisonModel comparison = dBContext.Comparisons.Find(Id);
if (comparison != null)
{
dBContext.Comparisons.Remove(comparison);
dBContext.SaveChanges();
}
return(comparison);
}
catch (Exception exception)
{
throw exception;
}
}
public void AddComparison(ComparisonModel comparison)
{
if (Comparisons.Count == 0)
{
Comparisons.Add(comparison);
ReloadRows(new NSIndexPath[] { NSIndexPath.FromRowSection(0, 0) }, UITableViewRowAnimation.Fade);
}
else
{
Comparisons.Add(comparison);
Comparisons = Comparisons.OrderBy(c => c.Name).ToList();
BeginUpdates();
InsertRows(new NSIndexPath[] { NSIndexPath.FromRowSection(Comparisons.IndexOf(comparison), 0) }, UITableViewRowAnimation.Fade);
EndUpdates();
}
SetScrollAndSelection();
}
// partial void xyz -> initialize
private void OnShowContextLegendChanged()
{
if (!ComparisonRecords.Any())
{
return;
}
if (!IsContextLegendActive)
{
ComparisonModel.Series.ForEach(series => series.Title = null);
}
else
{
OnComparisonContextChanged();
}
ComparisonModel.InvalidatePlot(true);
}
public static ComparisonModel GetComparison(int id)
{
var commandText = _selectComparison + " where c.Id = @Id;";
var parameters = new Dictionary <string, object>();
parameters.Add("@Id", id);
ComparisonModel comparison = null;
SqlConnection.ReaderWithCommand(commandText, parameters, (reader) =>
{
if (reader.Read())
{
comparison = CreateComparison(reader);
}
});
return(comparison);
}
/// <summary>
/// Method to delete an perviously performed comparison provided it's Id
/// </summary>
/// <param name="Id"></param>
/// <returns></returns>
#region DeleteComparisonById
public ComparisonModel DeleteComparisonById(int Id)
{
try
{
ComparisonModel quantity = dBContext.Comparisons.Find(Id);
if (quantity != null)
{
dBContext.Comparisons.Remove(quantity);
dBContext.SaveChanges();
}
return(quantity);
}
catch (Exception exception)
{
throw new Exception(exception.Message);
}
}
public ComparisonModel StartCompare(string folderOne,
string folderTwo)
{
var originalFolder = new DirectoryInfo(folderOne);
var latestFolder = new DirectoryInfo(folderTwo);
// Ensure that folderOne is the latest folder
if (originalFolder.CreationTime > latestFolder.CreationTime)
{
var tempFolder = originalFolder;
originalFolder = latestFolder;
latestFolder = tempFolder;
}
var firstFolderFileNames = GetFilesNames(originalFolder);
var secondFolderFileNames = GetFilesNames(latestFolder);
IEnumerable <string> removedFromOriginal = firstFolderFileNames.Except(secondFolderFileNames);
IEnumerable <string> addedToOriginal = secondFolderFileNames.Except(firstFolderFileNames);
if (_config.ConsoleLogging)
{
FolderDifferencesConsoleLogging(removedFromOriginal, addedToOriginal, originalFolder.Name, latestFolder.Name);
}
// Check .txt files for changes
var(linesAddedToLatest, linesRemovedFromOriginal) = GetTextFileChanges(originalFolder, latestFolder);
if (_config.ConsoleLogging)
{
TextDifferencesConsoleLogging(linesAddedToLatest, linesRemovedFromOriginal);
}
var comparisonModel = new ComparisonModel()
{
LinesAddedToLatest = linesAddedToLatest,
LinesRemovedFromOriginal = linesRemovedFromOriginal,
FilesAdded = addedToOriginal,
FilesRemoved = removedFromOriginal,
IsComparisonComplete = true,
};
return(comparisonModel);
}
public void InvalidObjectPassedToCompareShouldReturnBadRequesst()
{
//Creating Commparison Model.
ComparisonModel model = new ComparisonModel()
{
Id = 1,
Value_One = 5,
Value_One_Unit = "Inch",
Value_Two = 5,
Value_Two_Unit = "",
Result = ""
};
//Calling Compare Function.
var BadResult = controller.Compare(model);
//Asserting Values.
Assert.IsType <BadRequestObjectResult>(BadResult);
}
// partial void xyz -> initialize
private void OnShowContextLegendChanged()
{
if (!ComparisonRecords.Any())
{
return;
}
if (!IsContextLegendActive)
{
ComparisonModel.Series.ForEach(series => series.Title = null);
}
else
{
switch (_selectedComparisonContext)
{
case EComparisonContext.DateTime:
SetLabelDateTimeContext();
break;
case EComparisonContext.CPU:
SetLabelCpuContext();
break;
case EComparisonContext.GPU:
SetLabelGpuContext();
break;
case EComparisonContext.SystemRam:
SetLabelSystemRamContext();
break;
case EComparisonContext.Custom:
SetLabelCustomContext();
break;
default:
SetLabelDateTimeContext();
break;
}
}
ComparisonModel.InvalidatePlot(true);
}
