hipaa – How to block duplicate accounts without leaking PII?

We need to block multiple accounts from being created using identical PII without leaking any information regarding the original account. What is the best way to:

  • Inform the person trying to create an account that they cannot
  • While not telling them why
  • While also enabling the original account to recover their account if they were accidentally attempting to log in?

Is there a standard/best practice way to handle this?

My thoughts are that you simply say “We are unable to create an account at this time. If you have a previous account, reset your password here.” Followed with the standard “if you have an account, you will receive a password reset email”

This is not related to this previous question Detect duplicates without exposing underlying data, although that has a really great answer that’s well worth reading and actually may help solve the backend part of the issue. It is also not specifically related to password resets. It has to do with account creation only.

Game Architecture: Class leaking into almost all files

We currently have the problem that our main class GameController is being pulled into every backend file in our game. We’re wondering what are common solutions to this problem.

Here’s a bit more about the game architecture. The game is a board game, so since ~90-95% of the time there isn’t anything happening, the game is set up more like a rest API. It waits for a user prompt, when received, the msg is distributed to the respective components of the game and the proper logic is executed. No large update loops, just executes logic when prompted.

The problem is that as this msg cascades through the system, GameController acts more like a relay point between the systems. It’s how the nodes communicate to each other so that all game components are updated properly. The problem is that it’s created this system where all new/old classes contain a pointer to parentGame, so GameController is everywhere.

Are there any simple architectural solutions to avoid having every class contain a pointer to parentGame? Is this necessarily a bad thing?

Some example code:

class GameController {
    bank: Bank
    action: Action
    ...
}
class Bank {
    parentGame: GameController

    constructor(game: GameController) {
        this.parentGame = game
    }
}
class Action {
    parentGame: GameController

    constructor(game: GameController) {
        this.parentGame = game
    }
}
```

c++ – Wrapping 3rd party library – avoiding leaking abstraction

I’m currently developing an application using SFML. My biggest concern at the moment is making a layer of abstraction over the library, so I can easily change it to something else if needed. What I’m struggling with is designing an abstraction that’s intuitive and not leaky.

An example: drawing in SFML is done using drawable objects (implementing sf::Drawable) and objects capable of rendering them (sf::RenderTarget).

Say I want to wrap those and create my own IDrawable:

class IDrawable {
public:
    virtual void draw(IRenderTarget& target) const = 0;
};

Even though it looks nice, in order for the concrete classes to achieve their goal, they somehow still need to exchange information specific to SFML, i.e. IRenderTarget has to declare an abstraction breaking method, such as

virtual sf::RenderTarget& impl() = 0;

The only solution I can think of is creating concrete classes that require all library-specific parts to be passed via constructor, so there’s no cross-class communication of library-specific data. This way, IDrawable would change to:

class IDrawable {
public:
    virtual void draw() = 0;
}; 

Another solution would be abusing the friending mechanism, but I guess that’s not great, either.

In other words — are there any general guidelines for wrapping a 3rd party library, so that the created abstraction is not leaky (doesn’t require public accessor methods that break the encapsulation)?

SPFX web part, CSS is leaking across the sharepoint site

Unfortunately, no, there is no real way to prevent that from leaking. The problem is that, when you use a style library like that, you will have some very wide selectors included, and possibly affect certain things on the page, unless the SharePoint built-in CSS has selectors that are more specific and, therefore, cancel the library.

For example, I recently used Semantic UI React for some things, and Semantic UI has a selector / rule of

*, :before, :after {
  box-sizing: inherit;
}

which obviously is wildly wide, and made the SharePoint content area float a little and overlap at the bottom of the title area.

What you will have to do is find the library material that is being filtered and include some additional CSS in your web part to override the style library.

In my case, I had to add

div#contentRow, div#s4-titlerow {
  box-sizing: content-box !important;
}

to counteract the effects of Semantic UI CSS.

exit – Leaking context in Wolfram Script?

hello.nb

SetOptions[EvaluationNotebook[], CellContext -> Notebook

Print["hello"];

a = 1;
Print[a];

bye.nb

SetOptions[EvaluationNotebook[], CellContext -> Notebook

Print["bye"];
Print[a];

Wolfram Script

#! / usr / bin / env wolframscript
(* :: Package :: *)

Using FrontEnd[
  Map[
   NotebookEvaluate@FileNameJoin[{$UserDocumentsDirectory, #}] Y,
{"hello.nb", "bye.nb"}
]];

Leave[]

enter the description of the image here

enter the description of the image here