private void CreateHeaderGeneric(IReportable item, int row)
{
IEnumerable <PropertyInfo> itemProperties = item.GetType().GetProperties()
.Where(p => p.IsDefined(typeof(ReportHeaderPropertyAttribute), false));
////InsertRow(row); - THE INSERTION IS MADE BY THE OVERLOADS HOLDING IT, so it can specify styles if necessary
foreach (var property in itemProperties)
{
var attr = (ReportHeaderPropertyAttribute)Attribute.GetCustomAttribute(property, typeof(ReportHeaderPropertyAttribute));
string address = string.Empty;
string firstColumn = attr.Column;
if (attr.Merged)
{
//to merge cells if neccessary
string lastColumn = attr.LastColumn;
address = firstColumn + row + ":" + lastColumn + row;
}
else
{
address = firstColumn + row;
}
Cells[address].Value = attr.Value;
Cells[address].Merge = attr.Merged;
}
}
void WriteReportable(IReportable reportable, int currentIndentLevel = 0)
{
if (reportable == null)
{
throw new ArgumentNullException(nameof(reportable));
}
var performances = new [] {
ReportableType.Success,
ReportableType.SuccessWithResult,
ReportableType.Failure,
ReportableType.FailureWithError,
};
if (reportable.Type == ReportableType.GainAbility)
{
WriteGainAbility(reportable, currentIndentLevel);
}
else if (performances.Contains(reportable.Type))
{
WritePerformance(reportable, currentIndentLevel);
}
else
{
throw new ArgumentException(Resources.ExceptionFormats.ReportableMustBeGainAbilityOrPerformance);
}
}
public async Task ValidateReportViolationAsync(IReportable reportObject)
{
if (!await CanReportViolationAsync(reportObject))
{
throw buildException();
}
}
public IEnumerable <string> GetTags(IReportable reportable, IExecutionContext context)
{
if (configuration.Tags.HasFlag(Tags.Category))
{
foreach (var category in reportable.Category)
{
yield return(category);
}
}
if (configuration.Tags.HasFlag(Tags.Url))
{
yield return(GetFormattedUrl(context.Driver));
}
if (configuration.Tags.HasFlag(Tags.Topic))
{
yield return(context.TopicId);
}
if (configuration.CustomTags != null)
{
foreach (var tag in configuration.CustomTags)
{
yield return(tag);
}
}
}
void WritePerformance(IReportable reportable, int currentIndentLevel)
{
WriteIndent(currentIndentLevel);
WritePerformanceType(reportable, currentIndentLevel);
writer.Write(reportable.Report);
writer.WriteLine();
if (reportable.Type == ReportableType.SuccessWithResult)
{
WriteResult(reportable, currentIndentLevel);
}
else if (reportable.Type == ReportableType.Failure)
{
WriteFailure(reportable, currentIndentLevel);
}
else if (reportable.Type == ReportableType.FailureWithError && !reportable.Reportables.Any())
{
WriteFailure(reportable, currentIndentLevel);
}
foreach (var child in reportable.Reportables)
{
WriteReportable(child, currentIndentLevel + 1);
}
}
protected ExcelRow CreateTableHeader(IReportable item, int row, int copyStylesFromRow)
{
ExcelRow resultRow = InsertRow(row, copyStylesFromRow);
CreateHeaderGeneric(item, row);
return(resultRow);
}
protected ExcelRow PopulateLine(IReportable item, int row, ExcelNamedStyleXml namedStyle)
{
ExcelRow resultRow = InsertRow(row, namedStyle);
PopulateLineGeneric(item, row);
return(resultRow);
}
protected ExcelRow PopulateLine(IReportable item, int row, ExcelRow copyStylesFromRow)
{
ExcelRow resultRow = InsertRow(row, copyStylesFromRow);
PopulateLineGeneric(item, row);
return(resultRow);
}
protected ExcelRow CreateTableHeader(IReportable item, int row, ExcelNamedStyleXml namedStyle)
{
ExcelRow resultRow = InsertRow(row, namedStyle);
CreateHeaderGeneric(item, row);
return(resultRow);
}
void WriteGainAbility(IReportable reportable, int currentIndentLevel)
{
WriteIndent(currentIndentLevel);
WritePerformanceType(reportable, currentIndentLevel);
writer.Write(reportable.Report);
writer.WriteLine();
}
protected ExcelRow PopulateLine(IReportable item, int row)
{
ExcelRow resultRow = InsertRow(row);
this.PopulateLineGeneric(item, row);
return(resultRow);
}
public static FinderToken GetFinderToken(this IReportable @object)
{
var implementation = @object.Select(
(v => v is Commentary, Implementation.COMMENTARY),
(v => v is Profile, Implementation.PROFILE),
(v => v is Post, Implementation.POST)).Single();
return(new FinderToken(Interface.MODERATABLE_OBJECT, implementation, @object.Id));
}
/// <summary>
/// Initializes a new instance of the <see cref="T:CSF.Screenplay.Reporting.Models.ReportableModel"/> class.
/// </summary>
/// <param name="reportable">Reportable.</param>
public ReportableModel(IReportable reportable)
{
if (reportable == null)
{
throw new ArgumentNullException(nameof(reportable));
}
this.reportable = reportable;
}
/// <inheritdoc />
/// <exception cref="T:System.Exception">
/// ServiceConsumerFactory.Create returned null/invalid IHmsCloudService reference.
/// Check WCF HMS configuration.
/// </exception>
public void SendCasinoDataReport(IReportable reportable)
{
var dataReport = reportable as CasinoDataReport;
if (null == dataReport)
{
return;
}
using (
var cloudServiceProxy = ServiceConsumerFactory.Create <IHmsCloudService>(() => new HmsCloudServerProxy())
)
{
try
{
if (cloudServiceProxy?.Operations == null)
{
throw new Exception(
"ServiceConsumerFactory.Create returned null/invalid IHmsCloudService reference. Check WCF HMS configuration.");
}
// The TransactionScope here will provide behavior such that - if/when the call to
// DataAggregator.SuccessfulCasinoDataReport fails for some reason (e.g., problem
// writing to the database) - the transactional WCF/MSMQ message delivery will be
// rolled back (i.e., the messages will be discarded from the client-side MQ)
var txnOptions = new TransactionOptions {
IsolationLevel = IsolationLevel.RepeatableRead
};
using (var txnScope = new TransactionScope(TransactionScopeOption.Required, txnOptions))
{
cloudServiceProxy.Operations.ReportCasinoData(dataReport);
DataAggregator.SuccessfulCasinoDataReport(reportable.ReportGuid);
txnScope.Complete();
}
}
catch (FaultException fe)
{
Logger.Warn($"Service operation ReportCasinoData threw a fault: [{fe.Message}]");
DataAggregator.UnsuccessfulCasinoDataReport(reportable.ReportGuid);
}
catch (Exception ex)
{
Logger.Warn(
$"An unexpected error occurred while calling the ReportCasinoData service operation: [{ex.Message}]");
var innerEx = ex.InnerException;
while (null != innerEx)
{
Logger.Warn($"[{innerEx.Message}]");
innerEx = innerEx.InnerException;
}
DataAggregator.UnsuccessfulCasinoDataReport(reportable.ReportGuid);
Logger.Warn($"Stack Trace: [{Environment.StackTrace}]");
}
}
}
/// <summary>
/// Sends the casino data report.
/// </summary>
/// <param name="reportable">The casino data report.</param>
/// <inheritdoc />
public void SendCasinoDataReport(IReportable reportable)
{
var casinoDataReport = reportable as CasinoDataReport;
if (null == casinoDataReport)
{
return;
}
ExportCasinoDataReportAsJson(casinoDataReport);
}
private void AddDeviceChangeEvent(IReportable reportable, State state, DateTime dateTime)
{
if (!_eventStorage.ContainsKey(reportable))
{
_eventStorage.Add(reportable,
new List <KeyValuePair <DateTime, State> > {
new KeyValuePair <DateTime, State>(dateTime, state)
});
}
_eventStorage[reportable].Add(new KeyValuePair <DateTime, State>(dateTime, state));
}
void WriteFailure(IReportable reportable, int currentIndentLevel)
{
WriteResultOrFailureIndent(currentIndentLevel);
if (reportable.Error == null)
{
writer.WriteLine("FAILED");
return;
}
writer.WriteLine("FAILED: {0}", reportable.Error);
}
async Task <IActionResult> reportAsync(IReportable reportObject)
{
await S.Permissions.ValidateReportAsync(reportObject);
Report report;
var reportingUser = await S.UserManager.GetUserAsync(User);
if (reportObject is Post post)
{
report = new Report(reportingUser, post.Author, reportObject);
}
else if (reportObject is Profile profile)
{
var owner = await S.Db.Users.FirstOrDefaultAsync(u => u.Profile.Id == profile.Id);
report = new Report(reportingUser, owner, reportObject);
}
else if (reportObject is Commentary commentary)
{
report = new Report(reportingUser, commentary.Author, reportObject);
commentary.IsHidden = commentary.IsHidden
? true
: S.Decisions.ShouldHide(commentary);
}
else
{
throw new InvalidOperationException("Can't create report for object of such type");
}
S.Db.Reports.Add(report);
await S.Repository.AddUserActionAsync(reportingUser, new UserAction(ActionType.REPORT, reportObject));
if (S.Decisions.ShouldReportToModerator(reportObject))
{
var moderators = reportObject.Author.ModeratorsInChargeGroup;
var alreadyAdded = moderators.EntitiesToCheck.FirstOrDefault(e => e.Entity == reportObject);
if (alreadyAdded == null)
{
moderators.AddEntityToCheck(reportObject, CheckReason.TOO_MANY_REPORTS);
}
else
{
alreadyAdded.AddTime = DateTime.UtcNow;
}
}
await S.Db.SaveChangesAsync();
LayoutModel.AddMessage("Report has been submitted");
return(Redirect(S.History.GetLastURL()));
}
public async Task <bool> CanReportViolationAsync(IReportable reportObject)
{
var currentUser = await getCurrentUserOrNullAsync();
if (currentUser == null || currentUser.Status.State != ProfileState.ACTIVE)
{
return(false);
}
else
{
return(await isNotDeletedAsync(reportObject) &&
currentUser.Id != reportObject.Author.Id &&
currentUser.Role >= Role.MODERATOR &&
(reportObject.As <IModeratable>()?.ModerationInfo?.State ?? ModerationState.MODERATED) == ModerationState.MODERATED);
}
}
public async Task <bool> CanReportAsync(IReportable reportObject)
{
var currentUser = await getCurrentUserOrNullAsync();
if (currentUser == null || currentUser.Status.State != ProfileState.ACTIVE)
{
return(false);
}
else
{
return(await isNotDeletedAsync(reportObject) &&
currentUser.Id != reportObject.Author.Id &&
!reportObject.Reports.Any(r => r.Reporter.Id == currentUser.Id) && // Already reported
(reportObject.As <IModeratable>()?.ModerationInfo?.State ?? ModerationState.MODERATED) == ModerationState.MODERATED &&
currentUser.Role == Role.USER);
}
}
public void Report(IReportable reportable, int[] affectedUserIds)
{
_activityLogService.LogActivity(reportable);
var notification = reportable.Compose(_serviceProvider);
foreach (int userId in affectedUserIds)
{
_notificationSenderService.SendNotificationAsync(new CreateUserNotificationDto
{
isLink = notification.isLink,
Link = notification.Link,
Message = notification.Message,
Subject = notification.Subject,
UserId = userId
});
}
}
public static void Add(string name, IReportable obj)
{
Dictionary <string, IReportable> obj2;
Monitor.Enter(obj2 = reportableObjects);
try
{
if (reportableObjects.ContainsKey(name))
{
reportableObjects[name] = obj;
}
else
{
reportableObjects.Add(name, obj);
}
}
finally
{
Monitor.Exit(obj2);
}
}
public ReportModel(IReportable engine, ActivityModel activityModel)
{
_activityModel = activityModel;
_engine = engine;
_engine.StatusUpdate += engine_StatusUpdate;
_engine.MessageUpdate += engine_MessageUpdate;
_engine.GotTick += engine_GotTick;
_engine.GotFill += engine_GotFill;
_engine.GotOrder += engine_GotOrder;
_engine.GotPosition += engine_GotPosition;
_engine.GotPlot += engine_GotPlot;
_engine.GotIndicators += engine_GotIndicators;
_engine.EngineReset += engine_Reset;
_engine.EngineComplete += engine_Complete;
// Default each dispatchable type to the current thread's dispatcher. Any controls which register a dispatcher will change this.
var dispatchValues = Enum.GetValues(typeof(DispatchableType)).Cast <DispatchableType>();
foreach (var _value in dispatchValues)
{
_dispatchingMap[_value] = Dispatcher.CurrentDispatcher;
}
}
public Long(IReportable implementation) : base(implementation)
{
}
/// <summary>
/// Report a single, named, reportable value.
/// </summary>
public static void Value([Localizable(true)] string name, IReportable reportable)
{
CountCallsToValues.Increment();
reportable.ReportValue(0, name);
}
void WriteResult(IReportable reportable, int currentIndentLevel)
{
WriteResultOrFailureIndent(currentIndentLevel);
writer.WriteLine("Result: " + reportable.Result);
}
void WritePerformanceType(IReportable reportable, int currentIndentLevel)
{
writer.Write("{0,5} ", GetPerformanceTypeString(reportable.Category, currentIndentLevel));
}
/// <summary>
/// Initializes a new instance of the <see cref="ApplicationEventMessage" /> class.
/// </summary>
/// <param name="reportableObject">
/// An object representing the reportable event.
/// </param>
/// <param name="correlationIdentifier">
/// A unique identifier that is assigned to related messages.
/// </param>
/// <param name="identifier">
/// A unique identifier for the message.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="reportableObject" /> is <see langword="null" />.
/// </exception>
/// <exception cref="ArgumentOutOfRangeException">
/// <paramref name="correlationIdentifier" /> is equal to <see cref="Guid.Empty" /> -or- <paramref name="identifier" /> is
/// equal to <see cref="Guid.Empty" />.
/// </exception>
public ApplicationEventMessage(IReportable reportableObject, Guid correlationIdentifier, Guid identifier)
: this(reportableObject.RejectIf().IsNull(nameof(reportableObject)).TargetArgument.ComposeReportableEvent(), correlationIdentifier, identifier)
{
return;
}
protected Report(IReportable implementation)
{
Implementation = implementation;
}
public Violation(User reporter, User reportObjectOwner, IReportable reportObject, string description) : base(reporter, reportObjectOwner, reportObject)
{
Description = description ?? throw new ArgumentNullException(nameof(description));
}