public void createScript(string Username, string NameOfScript)
{
if (Scripts.ExistsBo(CanvasScriptKey.Create(Username, NameOfScript)))
{
// vorhandenes Script zurückgeben
Scripts.GetBo(CanvasScriptKey.Create(Username, NameOfScript));
}
else
{
if (Users.ExistsBo(Username))
{
var e = ScriptsSet.Create();
ScriptsSet.Add(e);
e.Name = NameOfScript;
e.User = UserNamesSet.Find(Username).User;
e.Created = DateTime.Now;
e.Modified = e.Created;
e.ScriptAsJson = "[]";
ScriptsSet.Add(e);
}
else
{
throw new ArgumentException("Der Benutzer mit dem Namen " + Username + " existiert nicht.", "Username");
}
}
}
public void deleteUser(string username)
{
var rec = _UsersTab.Find(r => r.Name == username);
if (rec != null)
{
// Alle Scripte vom Benutzer löschen
var bld = Scripts.getFilteredAndSortedSetBuilder();
bld.defAuthor(username);
var ScriptsOfUser = bld.GetSet();
foreach (var script in ScriptsOfUser.Get())
{
_cudActions.Enqueue(() => Scripts.RemoveBo(CanvasScriptKey.Create(username, script.Name)));
}
// Benutzer löschen
_cudActions.Enqueue(() =>
{
_UsersTab.Remove(rec);
});
}
else
{
throw new System.Data.RowNotInTableException("User " + username + " wurde nicht gefunden.");
}
}
public void createScript(string Authorname, string NameOfScript)
{
// Der Benutzer muss bereits existieren
if (Users.ExistsBo(Authorname))
{
if (!Scripts.ExistsBo(CanvasScriptKey.Create(Authorname, NameOfScript)))
{
var user = Users.GetBo(Authorname);
var entity = new CanvasScript();
entity._Name = NameOfScript;
entity._Created = DateTime.Now;
entity._Author = user.Name;
entity._ScriptAsJson = CanvasScriptServer.Bo.PredefinedScripts.DefaultScript;
_cudActions.Enqueue(() => _ScriptsTab.Add(entity));
}
else
{
throw new System.Data.ConstraintException("Das Skript " + NameOfScript + " für den Autor " + Authorname + " existiert bereits");
}
}
else
{
throw new System.Data.ConstraintException("Scriptautor " + Authorname + " existiert nicht. Das Skript " + NameOfScript + " konnte nicht angelegt werden");
}
}
public override void RemoveBo(CanvasScriptKey id)
{
System.Diagnostics.Contracts.Contract.Requires(!string.IsNullOrWhiteSpace(id.Scriptname));
var entity = _ScriptList.Single(GetBoIDTestIntern(id));
_cudActions.Enqueue(() => _ScriptList.Remove(entity));
}
public string Post([FromBody] Models.CanvasScriptsMgmt.ScriptSimple scriptFromClient)
{
var scriptBuilder = unitOfWork.Scripts.GetBoBuilder(CanvasScriptKey.Create(scriptFromClient.userName, scriptFromClient.scriptName));
scriptBuilder.setScript(scriptFromClient.scriptJson);
unitOfWork.SubmitChanges();
return(scriptFromClient.scriptJson);
}
public ActionResult Delete(string username, string scriptname)
{
unitOfWork.Scripts.RemoveBo(CanvasScriptKey.Create(username, scriptname));
unitOfWork.SubmitChanges();
var Model = CreateIndexViewModel(username);
return(View("Index", Model));
}
public override void RemoveBo(CanvasScriptKey id)
{
var script = GetScript(id);
if (null != script)
{
Orm.ScriptsSet.Remove(script);
}
else
{
throw new Exception("Das zu löschende Script mit dem Namen " + id.Scriptname + "existiert nicht");
}
}
//
public HttpResponseMessage Get(string userName, string scriptName)
{
var script = unitOfWork.Scripts.GetBo(CanvasScriptKey.Create(userName, scriptName));
if (script == null)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
//var response = Request.CreateResponse(HttpStatusCode.OK);
var response = new HttpResponseMessage(HttpStatusCode.OK);
response.Content = new CanvasScriptAsJsonContent(script.ScriptAsJson);
return(response);
}
public ICanvasScript ScriptById(string id)
{
var parts = id.Split(':');
if (parts.Count() != 2)
{
throw new HttpResponseException(new HttpResponseMessage()
{
StatusCode = HttpStatusCode.BadRequest,
ReasonPhrase = "Schlüssel ungültig. Schüssel muss definiert sein durch: id=author:scriptname"
});
}
var script = unitOfWork.Scripts.GetBo(CanvasScriptKey.Create(parts[0], parts[1]));
if (script == null)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
return(script);
}
public void UserRepositoryTest()
{
var unitOfWorks = new Mocks.CanvasScriptServerUnitOfWork();
unitOfWorks.Users.CreateBoAndAdd("Anton");
unitOfWorks.Users.CreateBoAndAdd("Berta");
var allUsers = unitOfWorks.Users.getFilteredSortedSetBuilder().GetSet();
Assert.AreEqual(0, allUsers.Get().Count(), "Es wurde keine Eintrag in Users erwartet");
unitOfWorks.SubmitChanges();
Assert.AreEqual(2, allUsers.Get().Count(), "Es wurden zwei Einträge in Users erwartet");
var Anton = unitOfWorks.Users.GetBo("Anton");
var Berta = unitOfWorks.Users.GetBo("Berta");
unitOfWorks.createScript(Anton.Name, "T1");
unitOfWorks.SubmitChanges();
// Mittels Builder die Teilmenge von Antons Scripte definieren
var AntonScriptsSetBld = unitOfWorks.Scripts.getFilteredAndSortedSetBuilder();
AntonScriptsSetBld.defAuthor("Anton");
// Teilmenge erzeugen
var AntonScripts = AntonScriptsSetBld.GetSet();
Assert.AreEqual(1, AntonScripts.Count(), "Anton sollte ein Skript besitzen");
// Mittels Builder die Teilmenge von Bertas Scripte definieren
var BertaScriptsSetBld = unitOfWorks.Scripts.getFilteredAndSortedSetBuilder();
BertaScriptsSetBld.defAuthor("Berta");
// Teilmenge erzeugen
var BertaScripts = BertaScriptsSetBld.GetSet();
Assert.AreEqual(0, BertaScripts.Count(), "Berta sollte ein Skript besitzen");
// Zugriff auf ein Script von Anton, um es zu aktualisieren
var T1 = unitOfWorks.Scripts.GetBoBuilder(CanvasScriptKey.Create(Anton.Name, "T1"));
T1.setScript("[]");
// Neues Script für Berta anlegen
unitOfWorks.createScript(Berta.Name, "T1");
unitOfWorks.SubmitChanges();
Assert.AreEqual(1, AntonScripts.Count(), "Anton sollte ein Skript besitzen");
Assert.AreEqual("[]", AntonScripts.Get().First().ScriptAsJson, "Antons Script sollte leer sein");
Assert.AreEqual(1, BertaScripts.Count(), "Berta sollte ein Skript besitzen");
unitOfWorks.createScript(Berta.Name, "T2");
unitOfWorks.createScript(Anton.Name, "T2");
unitOfWorks.SubmitChanges();
Assert.AreEqual(2, AntonScripts.Count(), "Anton sollte ein Skript besitzen");
Assert.AreEqual(2, BertaScripts.Count(), "Berta sollte ein Skript besitzen");
unitOfWorks.Scripts.RemoveBo(CanvasScriptKey.Create(Berta.Name, "T2"));
unitOfWorks.SubmitChanges();
Assert.AreEqual(2, AntonScripts.Count(), "Anton sollte zwei Skripte besitzen");
Assert.AreEqual(1, BertaScripts.Count(), "Berta sollte ein Skript besitzen");
var SortByScriptCountBld = unitOfWorks.Users.getFilteredSortedSetBuilder();
SortByScriptCountBld.sortByScriptCount(true);
var SortByScriptCount = SortByScriptCountBld.GetSet();
Assert.AreEqual(2, SortByScriptCount.Count());
Assert.AreEqual("Anton", SortByScriptCount.Get().First().Name);
}
public override ICanvasScript GetBo(CanvasScriptKey id)
{
return(_ScriptList.Find(r => r.AuthorName == id.Username && r.Name == id.Scriptname));
}
public override bool ExistsBo(CanvasScriptKey id)
{
return(_ScriptList.Any(GetBoIDTestIntern(id)));
}
internal Scripts GetScript(CanvasScriptKey id)
{
return(Orm.ScriptsSet.Include(r => r.User.Name).FirstOrDefault(r => r.User.Name.Name == id.Username && r.Name == id.Scriptname));
}
public void CanvasScriptServer_DB_UnitOfWork()
{
CanvasScriptServer.ICanvasScriptServerUnitOfWork UofW = orm;
UofW.Users.CreateBoAndAdd("Anton");
UofW.Users.CreateBoAndAdd("Berta");
UofW.Users.CreateBoAndAdd("Cäsar");
UofW.SubmitChanges();
var Anton = UofW.Users.GetBo("Anton");
Assert.AreEqual("Anton", Anton.Name);
var Berta = UofW.Users.GetBo("Berta");
Assert.AreEqual("Berta", Berta.Name);
UofW.createScript(Berta.Name, "T3");
UofW.createScript(Berta.Name, "T5");
UofW.createScript(Berta.Name, "T2");
UofW.createScript(Anton.Name, "T2");
UofW.createScript(Anton.Name, "T3");
UofW.createScript(Anton.Name, "T1");
UofW.SubmitChanges();
// Menge aller Benutzer über Repository bilden
var AllUsersBld = UofW.Users.getFilteredSortedSetBuilder();
var AllUsers = AllUsersBld.GetSet();
Assert.AreEqual(3, AllUsers.Count());
// Menge aller Scripte über Repository bilden
var AllScriptsBld = UofW.Scripts.getFilteredAndSortedSetBuilder();
AllScriptsBld.OrderByAuthor(false);
AllScriptsBld.OrderByName(true);
var AllScripts = AllScriptsBld.GetSet();
Assert.AreEqual(6, AllScripts.Count());
var allScriptsSorted = AllScripts.Get().ToArray();
Assert.AreEqual("Anton", allScriptsSorted[0].AuthorName);
Assert.AreEqual("T3", allScriptsSorted[0].Name);
Assert.AreEqual("Anton", allScriptsSorted[1].AuthorName);
Assert.AreEqual("T2", allScriptsSorted[1].Name);
Assert.AreEqual("Anton", allScriptsSorted[2].AuthorName);
Assert.AreEqual("T1", allScriptsSorted[2].Name);
Assert.AreEqual("Berta", allScriptsSorted[3].AuthorName);
Assert.AreEqual("T5", allScriptsSorted[3].Name);
Assert.AreEqual("Berta", allScriptsSorted[4].AuthorName);
Assert.AreEqual("T3", allScriptsSorted[4].Name);
Assert.AreEqual("Berta", allScriptsSorted[5].AuthorName);
Assert.AreEqual("T2", allScriptsSorted[5].Name);
// Teilmenge aller Scripte von Anton bilden
var AntonsScriptsBld = UofW.Scripts.getFilteredAndSortedSetBuilder();
AntonsScriptsBld.defAuthor(Anton.Name);
var AntonsScripts = AntonsScriptsBld.GetSet();
Assert.AreEqual(AntonsScripts.Count(), 3, "Anton sollte drei Skripte besitzen");
var T2Bld = UofW.Scripts.GetBoBuilder(CanvasScriptKey.Create(Anton.Name, "T2"));
T2Bld.setScript("[{\"beginPath\": true}, {\"strokeStyle\": \"#FF0000\"}, {\"lineTo\": {X: 100, Y: 100}}]");
// Alle Scripte von Berta auflisten
var Caesar = UofW.Users.GetBo("Cäsar");
Assert.AreEqual("Cäsar", Caesar.Name);
var CaesarsScriptsBld = UofW.Scripts.getFilteredAndSortedSetBuilder();
CaesarsScriptsBld.defAuthor(Caesar.Name);
var CaesarsScripts = CaesarsScriptsBld.GetSet();
Assert.IsFalse(CaesarsScripts.Any(), "Cäsar sollte keine Skripte besitzen");
UofW.deleteUser("Cäsar");
UofW.SubmitChanges();
Assert.AreEqual(2, AllUsers.Count());
try
{
UofW.deleteUser(Anton.Name);
Assert.Fail("Anton darf sich nich löschen lassen, solange ihm Skripte zugeordnet sind");
}
catch (Exception ex)
{
}
//foreach (var script in AntonsScripts.Get())
//{
// UofW.Scripts.RemoveBo(CanvasScriptKey.Create(script.AuthorName, script.Name));
//}
//UofW.deleteUser(Anton.Name);
//UofW.SubmitChanges();
//var BertasScriptsBld = UofW.Scripts.getFilteredAndSortedSetBuilder();
//BertasScriptsBld.defAuthor(Berta.Name);
//var BertasScripts = BertasScriptsBld.GetSet();
//foreach (var script in BertasScripts.Get())
//{
// UofW.Scripts.RemoveBo(CanvasScriptKey.Create(script.AuthorName, script.Name));
//}
//UofW.deleteUser(Berta.Name);
//UofW.SubmitChanges();
//Assert.IsFalse(AllUsers.Any(), "Alle Benutzer sollten gelöscht sein");
//Assert.IsFalse(AllScripts.Any(), "Alle Skripte sollten gelöscht sein");
}
public override ICanvasScriptBuilder GetBoBuilder(CanvasScriptKey id)
{
return(GetScript(id));
}
public override ICanvasScript GetBo(CanvasScriptKey id)
{
return(new CanvasScriptFlat(GetScript(id)));
}
public ActionResult Edit(string userName, string scriptName)
{
var script = unitOfWork.Scripts.GetBo(CanvasScriptKey.Create(userName, scriptName)); //.BoCollection.First(r => r.Name == scriptName && r.Author.Name == userName);
return(View(script));
}
/// <summary>
/// Builder zum Aktualisieren eines Datensatzes abrufen
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public override ICanvasScriptBuilder GetBoBuilder(CanvasScriptKey id)
{
return(new Bo.CanvasScriptBuilder(_ScriptList.Find(r => r.AuthorName == id.Username && r.Name == id.Scriptname)));
}
Func <CanvasScript, bool> GetBoIDTestIntern(CanvasScriptKey id)
{
System.Diagnostics.Contracts.Contract.Requires(!string.IsNullOrWhiteSpace(id.Scriptname));
return(r => r.AuthorName == id.Username && r.Name == id.Scriptname);
}
public override bool ExistsBo(CanvasScriptKey id)
{
return(Orm.ScriptsSet.Include(r => r.User.Name).Any(r => r.Name == id.Scriptname && r.User.Name.Name == id.Username));
}