public ActionResult EditCapacityGroup(CapacityGroupEditModel model)
{
var currGroup = Db.CapacityGroups.SingleOrDefault(g => g.Id == model.CapacityGroup.Id);
if (currGroup != null)
{
currGroup.Name = model.Name;
currGroup.InSS = model.InSS;
currGroup.InWS = model.InWS;
currGroup.Aliases.Clear();
if (!string.IsNullOrEmpty(model.AliasList))
{
var elems = model.AliasList.Split(',');
foreach (var elem in elems)
{
var groupAlias = new GroupAlias
{
CapacityGroup = currGroup,
Name = elem
};
Db.GroupAliases.Add(groupAlias);
}
}
Db.SaveChanges();
}
return(RedirectToAction("GroupList", new { id = currGroup.CurriculumGroup.Curriculum.Id }));
}
/// <summary>
///
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public ActionResult Details(Guid id)
{
var curriculum = Db.Curricula.SingleOrDefault(c => c.Id == id);
if (curriculum.ShortName.Equals("WI"))
{
var g = curriculum.CurriculumGroups.SingleOrDefault(x => x.Name.Equals("2"));
if (g != null)
{
var g2 = g.CapacityGroups.SingleOrDefault(x => x.Name.Equals("C"));
var g3 = g2.Aliases.SingleOrDefault(x => x.Name.Equals("2C-IMT"));
if (g3 == null)
{
g3 = new GroupAlias
{
CapacityGroup = g2,
Name = "2C-IMT"
};
Db.GroupAliases.Add(g3);
Db.SaveChanges();
}
}
}
SetEditRights();
return(View(curriculum));
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public ActionResult InsertIMT()
{
var wi = Db.Curricula.SingleOrDefault(x => x.ShortName.Equals("WI"));
var wi1 = wi.CurriculumGroups.SingleOrDefault(x => x.Name.Equals("1"));
var wi1C = wi1.CapacityGroups.SingleOrDefault(x => x.Name.Equals("C"));
var imt = new GroupAlias
{
CapacityGroup = wi1C,
Name = "1C-IMT"
};
Db.GroupAliases.Add(imt);
wi1C.Aliases.Add(imt);
Db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult ImportData(HttpPostedFileBase importFile)
{
if (importFile != null)
{
var bytes = new byte[importFile.ContentLength];
importFile.InputStream.Read(bytes, 0, importFile.ContentLength);
var stream = new System.IO.MemoryStream(bytes);
var reader = new System.IO.StreamReader(stream, Encoding.Default);
var text = reader.ReadToEnd();
string[] lines = text.Split('\n');
var i = 0;
foreach (var line in lines)
{
if (i > 0)
{
string newline = line.Trim();
if (!string.IsNullOrEmpty(newline))
{
string[] words = newline.Split(';');
var fk = words[0]; // Kurzname Fakultät
var cu = words[1]; // Kurzname Studiengang
var sg = words[2]; // Name Studiengruppe
var cg = words[3]; // Name Kapazitätsgruppe - kann leer sein
var ws = words[4]; // Kapazitätsgruppe wird im WS angeboten
var ss = words[5]; // Kapazitätsgruppe wird im SS angeboten
var untis = words[6]; // Kürzel gpUntis
// Vorbedingung
// Fakultät und Studiengang müssen existieren
var faculty = Db.Organisers.SingleOrDefault(f => f.ShortName.Equals(fk));
if (faculty != null)
{
var curriculum = faculty.Curricula.SingleOrDefault(c => c.ShortName.Equals(cu));
if (curriculum != null)
{
var studyGroup = curriculum.CurriculumGroups.SingleOrDefault(g => g.Name.Equals(sg));
// Neue Studiengruppen werden automatisch angelegt
if (studyGroup == null)
{
studyGroup = new CurriculumGroup
{
Name = sg,
Curriculum = curriculum,
IsSubscribable = false
};
Db.CurriculumGroups.Add(studyGroup);
Db.SaveChanges();
}
var capacityGroup = string.IsNullOrEmpty(cg) ?
studyGroup.CapacityGroups.SingleOrDefault(g => string.IsNullOrEmpty(g.Name)) :
studyGroup.CapacityGroups.SingleOrDefault(g => g.Name.Equals(cg));
// Neue Kapazitätsgruppen werden automatisch angelegt
if (capacityGroup == null)
{
capacityGroup = new CapacityGroup
{
CurriculumGroup = studyGroup,
Name = cg
};
Db.CapacityGroups.Add(capacityGroup);
Db.SaveChanges();
}
// ggf. bereits vorhandene Eigenschaften überschreiben
capacityGroup.InWS = string.Equals(ws, "WS");
capacityGroup.InSS = string.Equals(ss, "SS");
Db.SaveChanges();
var alias = capacityGroup.Aliases.SingleOrDefault(a => a.Name.Equals(untis));
if (alias == null)
{
alias = new GroupAlias
{
CapacityGroup = capacityGroup,
Name = untis
};
Db.GroupAliases.Add(alias);
Db.SaveChanges();
}
}
}
}
}
i++;
}
}
return(RedirectToAction("Index"));
}
/// <summary>
///
/// </summary>
/// <param name="db"></param>
/// <param name="gruppenId">Gruppenalias nach dem in der Datenbank gesucht wird</param>
/// <returns></returns>
private List <SemesterGroup> InitSemesterGroups(TimeTableDbContext db, string gruppenId)
{
var semester = db.Semesters.SingleOrDefault(s => s.Id == _semId);
var org = db.Organisers.SingleOrDefault(x => x.Id == _orgId);
// Annahme, die Semestergruppen existieren!
var semGroupList = new List <SemesterGroup>();
// Annahme, die Semestergruppen existieren nicht alle und müssen ggf. angelegt werden
// damit man nach den Alias namen in Abhängigkeit der Studiengänge / Fakultät suchen kann
// so müssen die Namen derzeit auf globale Ebene eindeutig sein
var aliasList = db.GroupAliases.Where(g => g.Name.ToUpper().Equals(gruppenId.ToUpper()) &&
g.CapacityGroup.CurriculumGroup.Curriculum.Organiser.Id == _orgId).ToList();
// falls leer, jetzt in Zuordnungen nachsehen
if (!aliasList.Any())
{
var zuordnungen = _import.GruppenZuordnungen.Where(x => x.Alias.Equals(gruppenId));
foreach (var zuordnung in zuordnungen)
{
// Studiengang finden
var curr = db.Curricula.SingleOrDefault(x =>
x.ShortName.Equals(zuordnung.Studiengang) &&
x.Organiser.Id == org.Id);
if (curr == null)
{
curr = new TimeTable.Data.Curriculum
{
Organiser = org,
ShortName = zuordnung.Studiengang,
Name = zuordnung.Studiengang
};
db.Curricula.Add(curr);
}
var sg = curr.CurriculumGroups.SingleOrDefault(x => x.Name.Equals(zuordnung.Studiengruppe));
if (sg == null)
{
sg = new CurriculumGroup
{
Name = zuordnung.Studiengruppe,
IsSubscribable = true,
Curriculum = curr
};
db.CurriculumGroups.Add(sg);
curr.CurriculumGroups.Add(sg);
}
var cg = string.IsNullOrEmpty(zuordnung.Kapazitätsgruppe) ?
sg.CapacityGroups.SingleOrDefault(x => string.IsNullOrEmpty(x.Name)) :
sg.CapacityGroups.SingleOrDefault(x => x.Name.Equals(zuordnung.Kapazitätsgruppe));
if (cg == null)
{
cg = new CapacityGroup
{
InSS = true,
InWS = true,
Name = zuordnung.Kapazitätsgruppe,
CurriculumGroup = sg
};
db.CapacityGroups.Add(cg);
sg.CapacityGroups.Add(cg);
}
var al = cg.Aliases.SingleOrDefault(x => x.Name.Equals(zuordnung.Alias));
if (al == null)
{
al = new GroupAlias
{
Name = zuordnung.Alias,
CapacityGroup = cg
};
db.GroupAliases.Add(al);
cg.Aliases.Add(al);
}
aliasList.Add(al);
}
db.SaveChanges();
}
foreach (var groupAlias in aliasList)
{
// zugehörige Kapazitätsgruppe
var capGroup = groupAlias.CapacityGroup;
// im semester suchen
var semGroup = semester.Groups.SingleOrDefault(g => g.CapacityGroup.Id == capGroup.Id);
if (semGroup == null)
{
// semestergruppe gibt es nicht => auf jeden Fall anlegen
semGroup = new SemesterGroup
{
CapacityGroup = capGroup,
Semester = semester,
};
_Logger.InfoFormat("Semestergruppe {0} angelegt {1}", semGroup.FullName, gruppenId);
capGroup.SemesterGroups.Add(semGroup);
db.SemesterGroups.Add(semGroup);
db.SaveChanges();
}
semGroupList.Add(semGroup);
}
return(semGroupList);
}