public void UseItem(string input, Player CurrentPlayer)
{
if (UseCases.ContainsKey(input))
{
UseCases[input](CurrentPlayer);
}
else
{
System.Console.WriteLine("No reason to use this here.");
}
}
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
var useCases = new UseCases();
var formCalculator = new FormCalculator();
formCalculator.ZifferEingegeben += (sender, args) =>
{
var ergebnis = useCases.OperandErweitern(args.Ziffer);
formCalculator.ErgebnisAnzeigen(ergebnis);
};
formCalculator.IstGleichEingegeben += (sender, args) =>
{
var ergebnis = useCases.Rechnen();
formCalculator.BerechnungAuswerten(ergebnis);
};
formCalculator.OperatorEingegeben += (sender, args) =>
{
var ergebnis = useCases.Rechnen(args.Operator);
formCalculator.BerechnungAuswerten(ergebnis);
};
Application.Run(formCalculator);
}
public ResourceClassTests()
{
money = new Money();
prototype = new Prototypes();
usecase = new UseCases();
userstory = new UserStories();
}
public void Extract_ValidData_True()
{
UseCases.PsarcExtract(Fixture.InputPsarc, Fixture.TempDir);
Directory.Exists(Fixture.TempDir).Should().BeTrue();
Directory.GetFiles(Fixture.TempDir, "*").Length.Should().Equals(23);
}
public void ActivateUseCase(UseCases useCase)
{
_useCaseStack.Push(useCase);
Messenger.Default.Send(new CanGoBackChangedMessage());
switch (useCase)
{
case UseCases.FrontPage:
HideAllContent();
DisplayContent(typeof (DoubleWidePage));
break;
case UseCases.ItemsPage:
HideAllContent();
DisplayContent(typeof (ItemsPage));
break;
case UseCases.ShowDog:
DisplayContent(typeof (DogPage));
break;
case UseCases.ShowKid:
DisplayContent(typeof (KidPage));
break;
case UseCases.ShowPopup:
DisplayContent(typeof (PopupPage));
break;
}
}
public virtual void RemoveUseCaseIntern(UseCase useCase)
{
if (UseCases != null)
{
UseCases.Remove(useCase);
}
}
private void InsertEAData()
{
var operationSuccess = true;
try
{
var db = new DatabaseOperations();
if (Scenarios.Any())
{
operationSuccess &= db.Insert(Scenarios);
}
if (UseCases.Any())
{
operationSuccess &= db.Insert(UseCases);
}
if (Steps.Any())
{
operationSuccess &= db.Insert(Steps);
}
if (operationSuccess)
{
MessageBox.Show(
"Import danych z Enterprise Architect przebiegł pomyślnie!", "OK!",
MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
catch (Exception e)
{
MessageBox.Show(
"W aplikacji wystąpił błąd!\n" + e, "Błąd!",
MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
throw;
}
}
public void Save_ValidData_True()
{
UseCases.PsarcSave(Fixture.TempDir, Fixture.OutputPsarc);
FileInfo file = new(Fixture.OutputPsarc);
file.Exists.Should().BeTrue();
file.Length.Should().BeGreaterOrEqualTo(new FileInfo(Fixture.InputPsarc).Length);
}
public BinaryFormatterFixture()
{
Serializer = new BinaryFormatterSerializer(Helper.EventFactory);
var services = Helper.CreateAggregateRootServices(0);
var rootAggregate = UseCases.Full().AsDirtyCustomerAggregate(services);
EventsFromDomain = rootAggregate.UncommitedEvents;
}
public void DeleteUseCase(UseCase.UseCaseTypes type, Schema intersectionDomain = null)
{
var item = UseCases.FirstOrDefault(k => k.Type == type && k.Schema?.Name == intersectionDomain?.Name);
if (item == null)
{
throw new Exception("Can't find use case");
}
UseCases.Remove(item);
}
public void Calculate()
{
var uc = UseCases.Select(x => new UseCase(x.Actor.Type, x.Type));
var tcf = TechnicalFactors.Select(x => x.ComplexityFactor);
var ecf = EnviromentFactors.Select(x => x.ComplexityFactor);
var project = new Project(tcf, ecf, uc);
var calculator = new SimpleUseCasePointCalculator();
UseCasePoints = calculator.CalculateUseCasePoints(project);
}
public MessagePackSerializerSpecFixture()
{
var services = Helper.CreateAggregateRootServices(0);
var rootAggregate = UseCases.Full().AsDirtyCustomerAggregate(services);
EventsFromDomain = rootAggregate.UncommitedEvents;
var eventTypes = EventsFromDomain.Select(x => x.GetType()).ToArray();
var options = MessagePackBuilder.CreateDefaultSerializerOptions();
Serializer = new Serializer(options, new EventFactory(eventTypes), new TypeIdTranslator(eventTypes));
}
public bool AddUseCaseIntern(UseCase useCase)
{
if (UseCases == null)
{
UseCases = new ObservableCollection <UseCase>();
}
if (UseCases.Contains(useCase))
{
return(false);
}
UseCases.Add(useCase);
return(true);
}
public IActionResult Post([FromBody] Category.Dto dto)
{
var category = UseCases.createCategory(dto);
if (category.IsOk)
{
var result = Category.dto(category.ResultValue);
return(Created("/api/v1/categories/" + result.id, result));
}
else
{
return(BadRequest(category.ErrorValue));
}
}
public void PrepareData(IEnumerable <XMLParse.EAScenario> result)
{
var currentDate = DateTime.Now;
try
{
foreach (var scenario in result)
{
var db = new DatabaseOperations();
scenario.Timestamp = currentDate;
scenario.PreviousVersionId = db.GetActive_EAscenarios(Project)
.Where(s => s.ProjectId == scenario.ProjectId && s.XmiId == scenario.XmiId)
.Select(s => s.Id)
.FirstOrDefault();
Scenarios.Add(DataMapper.MapEAScenario(scenario));
foreach (var useCase in scenario.UseCase)
{
useCase.Id = Guid.NewGuid();
useCase.Timestamp = currentDate;
useCase.EAScenarioId = scenario.Id;
UseCases.Add(useCase);
}
foreach (var step in scenario.Steps)
{
step.Id = Guid.NewGuid();
step.Timestamp = currentDate;
step.EAScenarioId = scenario.Id;
step.PreviousVersionId = db.GetActive_Steps()
.Where(s => s.EAScenarioId == scenario.Id && s.Guid == step.Id)
.Select(s => s.Id)
.FirstOrDefault();
Steps.Add(step);
}
}
InsertEAData();
}
catch (Exception e)
{
MessageBox.Show(
"W aplikacji wystąpił błąd!\n" + e, "Błąd!",
MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
throw;
}
}
public Input(
Name name,
UseCases useCases,
UserInterface userInterface,
DataAccess dataAccess,
Tips tips,
SkipRestore skipRestore)
{
this.Name = name;
this.UseCases = useCases;
this.UserInterface = userInterface;
this.DataAccess = dataAccess;
this.Tips = tips;
this.SkipRestore = skipRestore;
}
/// <summary>
/// Adds a new use case
/// </summary>
/// <param name="useCase"></param>
/// <returns></returns>
private UMLUseCase AddUseCase(UMLUseCase useCase)
{
foreach (UMLUseCase u in UseCases)
{
//if (useCase.Name == u.Name && useCase.Owner == u.Owner)
if (useCase.Name == u.Name)
{
u.Owner = useCase.Owner;
u.Collaborations = useCase.Collaborations;
return(u);
}
}
UseCases.Add(useCase);
return(useCase);
}
private string GetCommandlines()
{
StringBuilder script = new StringBuilder();
script.AppendLine("dotnet new clean \\");
script.AppendLine($"--use-cases { UseCases.ToString() } \\");
script.AppendLine($"--data-access { DataAccess.ToString() } \\");
script.AppendLine($"--user-interface { UserInterface.ToString() } \\");
script.AppendLine($"--tips { Tips.ToString() } \\");
script.AppendLine($"--skip-restore { SkipRestore.ToString() } \\");
script.AppendLine($"--name '{ Name.ToString()}'");
string output = script.ToString();
return(output);
}
public CleanTemplate(
Name name,
UseCases useCases,
UserInterface userInterface,
DataAccess dataAccess,
Tips tips,
SkipRestore skipRestore)
{
this.Name = name;
this.UseCases = useCases;
this.UserInterface = userInterface;
this.DataAccess = dataAccess;
this.Tips = tips;
this.SkipRestore = skipRestore;
this.OrderUtcDate = DateTime.UtcNow;
this.CommandLines = GetCommandlines();
}
public void AddUseCase(UseCase useCase)
{
var repeatedCrud = UseCases.Where(k => k.Type == useCase.Type);
if (repeatedCrud.Count() > 0 &&
(useCase.Type == UseCase.UseCaseTypes.Create ||
useCase.Type == UseCase.UseCaseTypes.DeleteByPk ||
useCase.Type == UseCase.UseCaseTypes.DeleteByUn ||
useCase.Type == UseCase.UseCaseTypes.RetrieveByPk ||
useCase.Type == UseCase.UseCaseTypes.RetrieveByUn ||
useCase.Type == UseCase.UseCaseTypes.Update))
{
throw new Exception("Repeated use case");
}
UseCases.Add(useCase);
}
public ArtifactNotificationDriver StartApplication()
{
var watchersFactory = Substitute.For <FileSystemWatcherFactory>();
_presenter = Substitute.For <ApplicationEventsPresenter>();
_diagnosticMessages = Substitute.For <DiagnosticMessages>();
_systemServices = Substitute.For <SystemServices>();
_handControlledFileSystemWatcher = new ManuallyTriggerableFileSystemWatcher();
watchersFactory.CreateFileSystemWatchers(_filters).Returns(_handControlledFileSystemWatcher);
var compositionRoot = new CompositionRoot(watchersFactory, _systemServices, _filters);
_useCases = compositionRoot.Compose(_presenter, _diagnosticMessages);
_useCases.Initialize();
return(this);
}
public Input(
Guid orderId,
Name name,
UseCases useCases,
UserInterface userInterface,
DataAccess dataAccess,
ServiceBus serviceBus,
Tips tips,
SkipRestore skipRestore)
{
this.OrderId = orderId;
this.Name = name;
this.UseCases = useCases;
this.UserInterface = userInterface;
this.DataAccess = dataAccess;
this.ServiceBus = serviceBus;
this.Tips = tips;
this.SkipRestore = skipRestore;
}
public void PsarcSave()
{
UseCases.PsarcSave(config.TempDir, Path.GetRandomFileName());
}
public void PsarcExtract()
{
UseCases.PsarcExtract(config.InputPsarc, config.TempDir);
}
public void PsarcOpen()
{
UseCases.PsarcOpen(config.InputPsarc);
}
public SynchronizedUseCases(UseCases innerObserver)
{
_innerObserver = innerObserver;
}
public MainWindow(UseCases useCases)
{
InitializeComponent();
_useCases = useCases;
}
public List <UseCase> GetAllUseCases()
{
return(UseCases
.ToList());
}
public void Open_ValidData_True()
{
Psarc psarc = UseCases.PsarcOpen(Fixture.InputPsarc);
psarc.TableOfContent.Count.Should().Be(23);
}
public FakeClientSideInterface(UseCases useCases, DiagnosticMessages diagnosticMessages, SystemServices systemServices)
{
_useCases = useCases;
_diagnosticMessages = diagnosticMessages;
_systemServices = systemServices;
}
