public void TestAddStudent_NumberStudentsIsNull_Exception(int numberStudents, Type result)
{
ResetStandart();
Type exception = null;
var group = new Group.Group(standatrNameGroup, standatrCoursGroup, standatrSeminarGroup, standatrTypeStudyGroup);
//arrange
try
{
//act
group.AddStudent(numberStudents);
}
catch (Exception ex)
{
exception = ex.GetType();
}
finally
{
//assert
Assert.AreEqual(result, exception);
Assert.AreEqual(0, group.NumberOfStutents);
Assert.AreEqual(standatrNameGroup, group.NameGroup);
Assert.AreEqual(standatrCoursGroup, group.Cours);
Assert.AreEqual(standatrSeminarGroup, group.Seminar);
Assert.AreEqual(standatrTypeStudyGroup, group.TypeOfTraining);
}
}
public void UT_Mtch()
{
boot.Init();
var model = mod.sr.SetModel(boot, initSupl: false);
Assert.IsTrue(model.elmGroups.Count > 0);
Assert.IsTrue(model.Rules.Count > 0);
var Rules = model.Rules.ToList();
var grps = model.elmGroups.ToList();
// test 1 Уголок L50x5 -> цена 7 209 руб
Rule.Rule rule = Rules.Find(x => x.sCS.Contains("Уголок"));
Group.Group gr = grps.Find(x => x.Prf.Contains("L"));
if (rule != null && gr != null)
{
rule.Init();
var m = new Mtch(gr, rule);
Assert.IsTrue(gr.totalPrice > 7000);
double rubPerKg = gr.totalPrice / gr.totalWeight;
Assert.IsTrue(rubPerKg > 20);
}
// test 2 Полоса -30 из Листа ЛСС
rule = Rules.Find(x => x.sCS.Contains("Лист"));
gr = grps.Find(x => x.Prf.Contains("—"));
if (rule != null && gr != null)
{
rule.Init();
var m = new Mtch(gr, rule);
Assert.IsTrue(gr.totalPrice > 7000);
double rubPerKg = gr.totalPrice / gr.totalWeight;
Assert.IsTrue(rubPerKg > 20);
}
// test 3 Бетон
rule = Rules.Find(x => x.sCS.Contains("бетон"));
gr = grps.Find(x => x.mat.Contains("b"));
if (rule != null && gr != null)
{
rule.Init();
var m = new Mtch(gr, rule);
Assert.IsTrue(gr.totalPrice > 7000);
double rubPerM3 = gr.totalPrice / gr.totalVolume; //.totalWeight;
Assert.IsTrue(rubPerM3 > 2000);
}
//foreach (var gr in model.elmGroups)
//{
// Assert.IsTrue(model.Rules.Count > 0);
// foreach (var rule in model.Rules)
// {
// Assert.IsNotNull(rule.CompSet.Supplier);
// Assert.IsTrue(rule.CompSet.Components.Count > 0);
// Mtch _match = new Mtch(gr, rule);
// }
//}
FileOp.AppQuit();
}
public void TestToString(string name, int cours, string seminar, Interface.Interface.TypeStudy typeStudy, string toString)
{
//arrange
var group = new Group.Group(name, cours, seminar, typeStudy);
//act
var str = group.ToString();
//assert
Assert.AreEqual(str, toString);
}
///////////////////// <summary>
///////////////////// setComp(doc) - fill price list of Components from doc
///////////////////// setComp(doc_name) - overload
///////////////////// </summary>
///////////////////// <param name="doc">price-list</param>
///////////////////// <returns>List of Components</returns>
///////////////////// <history>26.3.2016
///////////////////// 3.4.2016 - setComp(doc_name) overload
///////////////////// 8.4.2016 - remove unnecteesary fields - bug fix
///////////////////// 14.4.2016 - field mat = Material fill
///////////////////// </history>
//////////////////public static List<Component> setComp(string doc_name)
//////////////////{ return setComp(Docs.getDoc(doc_name)); }
//////////////////public static List<Component> setComp(Docs doc)
//////////////////{
////////////////// Log.set("setComp(" + doc.name + ")");
////////////////// List<int> docCompPars = Lib.GetPars(doc.LoadDescription);
////////////////// //-- заполнение массива комплектующих Comps из прайс-листа металлопроката
////////////////// List<Component> Comps = new List<Component>();
////////////////// for (int i = doc.i0; i <= doc.il; i++)
////////////////// {
////////////////// try
////////////////// {
////////////////// string descr = doc.Body.Strng(i, docCompPars[0]);
////////////////// double lng = 0;
////////////////// //-- разбор параметров LoadDescription
////////////////// List<int> strPars = Lib.GetPars(descr);
////////////////// string docDescr = doc.LoadDescription;
////////////////// int parShft = 0;
////////////////// while (docDescr.Contains('/'))
////////////////// {
////////////////// string[] s = doc.LoadDescription.Split('/');
////////////////// List<int> c = Lib.GetPars(s[0]);
////////////////// int pCol = c[c.Count() - 1]; // колонка - последний параметр до '/'
////////////////// List<int> p = Lib.GetPars(s[1]);
////////////////// lng = strPars[p[0] - 1]; // длина заготовки = параметр в str; индекс - первое число после '/'
// 29/3/2017 ///// docDescr = docDescr.Replace("/", "");
// устарело ///// parShft++;
////////////////// }
////////////////// if (lng == 0)
////////////////// lng = doc.Body.Int(i, docCompPars[1]) / 1000; // для lng указана колонка в LoadDescription
////////////////// double price = doc.Body.Double(i, docCompPars[2] + parShft);
////////////////// double wgt = 0.0; //!!! времянка -- пока вес будем брать только из Tekla
////////////////// string mat = ""; //!!! времянка -- материал нужно извлекать из description или описания - еще не написано!
////////////////// Comps.Add(new Component(descr, mat, lng, wgt, price));
////////////////// }
////////////////// catch { Msg.F("Err in setComp", doc.name); }
////////////////// }
////////////////// Log.exit();
////////////////// return Comps;
//////////////////}
#endif
public bool isMatch(Group.Group gr, Rule.Rule rule = null)
{
if (!isMatchGrRule(SType.Material, gr, rule))
{
return(false);
}
if (!isMatchGrRule(SType.Profile, gr, rule))
{
return(false);
}
return(true);
}
public void TestConstructor_NumberStudentsIsNotNull_True(int numberStudents)
{
ResetStandart();
//arrange
//act
var group = new Group.Group(standatrNameGroup, standatrCoursGroup, standatrSeminarGroup, standatrTypeStudyGroup, numberStudents);
Assert.AreEqual(numberStudents, group.NumberOfStutents);
Assert.AreEqual(standatrNameGroup, group.NameGroup);
Assert.AreEqual(standatrCoursGroup, group.Cours);
Assert.AreEqual(standatrSeminarGroup, group.Seminar);
Assert.AreEqual(standatrTypeStudyGroup, group.TypeOfTraining);
}
public void TestConstructor_NumberStudentsIsNull_True(string name, int cours, string seminar)
{
ResetStandart();
//arrange
//act
var group = new Group.Group(name, cours, seminar, standatrTypeStudyGroup);
//assert
Assert.AreEqual(0, group.NumberOfStutents);
Assert.AreEqual(name, group.NameGroup);
Assert.AreEqual(cours, group.Cours);
Assert.AreEqual(seminar, group.Seminar);
Assert.AreEqual(standatrTypeStudyGroup, group.TypeOfTraining);
}
public async Task <Group.Group> LoadGroupAsync()
{
var loadedGroup = await GetDataAsync(GroupURL);
var result = new Group.Group
{
Name = loadedGroup["name"].ToString(),
Description = HtmlFormatter.RemoveHtmlTags(loadedGroup["description"].ToString()),
City = loadedGroup["city"].ToString(),
ImageUrl = loadedGroup["group_photo"]["photo_link"].ToString()
};
return(result);
}
public void TestStandartValue()
{
ResetStandart();
//arrange
//act
var group = new Group.Group(standatrNameGroup, standatrCoursGroup, standatrSeminarGroup, standatrTypeStudyGroup);
//assert
Assert.AreEqual(0, group.NumberOfStutents);
Assert.AreEqual(standatrNameGroup, group.NameGroup);
Assert.AreEqual(standatrCoursGroup, group.Cours);
Assert.AreEqual(standatrSeminarGroup, group.Seminar);
Assert.AreEqual(standatrTypeStudyGroup, group.TypeOfTraining);
}
public void TestAddStudent_NumberStudentsIsNotNull_True(int numberStudents1, int numberStudents2, int result)
{
ResetStandart();
//arrange
var group = new Group.Group(standatrNameGroup, standatrCoursGroup, standatrSeminarGroup, standatrTypeStudyGroup, numberStudents1);
//act
group.AddStudent(numberStudents2);
Assert.AreEqual(result, group.NumberOfStutents);
Assert.AreEqual(standatrNameGroup, group.NameGroup);
Assert.AreEqual(standatrCoursGroup, group.Cours);
Assert.AreEqual(standatrSeminarGroup, group.Seminar);
Assert.AreEqual(standatrTypeStudyGroup, group.TypeOfTraining);
}
////////////// private void test_getSectionText()
////////////// {
////////////// Log.set("test_getSectionTest(Section.Material, text");
//28/5/////////////// 7/3/2017 ///////////////// TST.Eq(getSectionText(FP.Section.Material, "Профиль: L 20 x 5; M: C245; Price: 2690"), "c245");
////////////// Log.exit();
////////////// }
//////////////private void test_isSectionMatch()
//////////////{
////////////// Log.set("isSectionMatch(Section.Material, C245, rule.text)");
////////////// /////// 7/3/2017 //// bool ok = isSectionMatch(FP.Section.Material, "C245", "Профиль: L * x * ст*; длина: * = * м; M: ст *;");
////////////// Log.exit();
//////////////}
private void test_Mtch_1()
{
Log.set(" test_Mtch_1: Rule 4 и Group<C255, L20x4>");
Rule.Rule rule = new Rule.Rule(4);
ElmAttSet.ElmAttSet el = new ElmAttSet.ElmAttSet(
"ID56A7442F-0000-0D70-3134-353338303236",
"C245", "Steel", "Уголок20X4", 0, 0, 0, 1000);
Dictionary<string, ElmAttSet.ElmAttSet> els = new Dictionary<string, ElmAttSet.ElmAttSet>();
els.Add(el.guid, el);
List<string> guids = new List<string>(); guids.Add(el.guid);
Group.Group gr = new Group.Group(els, "C245", "Уголок20X4", guids);
Mtch match = new Mtch(gr, rule);
//6/4/17 TST.Eq(match.ok == OK.Match, true);
Log.exit();
}
static void Main(string[] args)
{
Student.Student Akim = new Student.Student("Akim", "Lyubchenko", 4, 5, 6, 7);
Student.Student Artem = new Student.Student("Artem", "Maklakov", 7, 8, 9, 10);
Student.Student Nikita = new Student.Student("Nikita", "Makeychik", 3, 6, 9);
Group.Group group2 = new Group.Group(2);
group2.AddStudent(Akim);
group2.AddStudent(Artem);
group2.AddStudent(Nikita);
System.Console.WriteLine($"AverageScore of group 2: {group2.AverageScore()}");
System.Console.WriteLine($"AverageScore of Akim 2: {Akim.AverageScore()}");
System.Console.ReadKey();
}
public virtual void UpdateImageFile(HttpContext context)
{
YZRequest request = new YZRequest(context);
int groupid = request.GetInt32("groupid");
string imageid = request.GetString("imageid");
using (IYZDbProvider provider = YZDbProviderManager.DefaultProvider)
{
using (IDbConnection cn = provider.OpenConnection())
{
Group.Group group = GroupManager.GetGroup(provider, cn, groupid);
group.ImageFileID = imageid;
GroupManager.Update(provider, cn, group);
}
}
}
public void TestToString(string groupName, int groupCours, string groupSeminar, TypeStudy groupTypeStudy, string[] nameSubject, int[] numberSubject, string result)
{
//arrange
IGroup group = new Group.Group(groupName, groupCours, groupSeminar, groupTypeStudy);
List <INumberOfLesson> numberOfLessons = new List <INumberOfLesson>();
for (int i = 0; i < nameSubject.Length; i++)
{
ISubject subject = new Subject.Subject(nameSubject[i]);
INumberOfLesson numberOfLesson = new NumberOfLesson.NumberOfLesson(subject, numberSubject[i]);
numberOfLessons.Add(numberOfLesson);
}
//act
PlanOfLessons.PlanOfLessons planOfLessons = new PlanOfLessons.PlanOfLessons(group, numberOfLessons);
//assert
Assert.AreEqual(result, planOfLessons.ToString());
}
public virtual object GetRootFolders(HttpContext context)
{
YZRequest request = new YZRequest(context);
int groupid = request.GetInt32("groupid", -1);
string folderType = request.GetString("folderType");
string uid = YZAuthHelper.LoginUserAccount;
FileSystem.FolderCollection rootFolders = new FileSystem.FolderCollection();
using (IYZDbProvider provider = YZDbProviderManager.DefaultProvider)
{
using (IDbConnection cn = provider.OpenConnection())
{
string filter = String.Format("FolderType=N'{0}'", provider.EncodeText(folderType));
LibraryCollection libs = LibraryManager.GetLibraries(provider, cn, uid, LibraryType.BPAFile.ToString(), null, null);
foreach (Library.Library lib in libs)
{
FileSystem.FolderCollection folders = FileSystem.DirectoryManager.GetFolders(provider, cn, lib.FolderID, filter, null);
foreach (FileSystem.Folder folder in folders)
{
folder.Name = lib.Name;
}
rootFolders.AddRange(folders);
}
if (groupid != -1)
{
Group.Group group = GroupManager.GetGroup(provider, cn, groupid);
FileSystem.FolderCollection folders = FileSystem.DirectoryManager.GetFolders(provider, cn, group.FolderID, filter, null);
foreach (FileSystem.Folder folder in folders)
{
folder.Name = group.Name;
}
rootFolders.AddRange(folders);
}
}
}
return(rootFolders);
}
public void TestConstructor_NumberStudentsIsNotNull_Exception(int numberStudents, Type result)
{
ResetStandart();
Type exception = null;
//arrange
try
{
//act
var group = new Group.Group(standatrNameGroup, standatrCoursGroup, standatrSeminarGroup, standatrTypeStudyGroup, numberStudents);
}
catch (Exception ex)
{
exception = ex.GetType();
}
finally
{
//assert
Assert.AreEqual(result, exception);
}
}
private void OnSave(object arg)
{
if (string.IsNullOrWhiteSpace(GroupName))
{
var localizationService = ServiceLocator.Current.GetInstance <ILocalizationService>();
var str = localizationService.Translate("usermanagment_empty_group_name_warning_label");
MessageBox.Show(str);
return;
}
var groupService = ServiceLocator.Current.GetInstance <IGroupService>();
var newGroup = new Group.Group()
{
GroupId = 0,
Ident = 0,
IsDefaultGroup = IsDefault,
Name = GroupName
};
groupService.Save(newGroup);
NewGroup = new GroupViewModel(newGroup);
}
public void TestConstructor_NumberStudentsIsNull_Exception(string name, int cours, string seminar, Type result)
{
ResetStandart();
Type exception = null;
//arrange
try
{
//act
var group = new Group.Group(name, cours, seminar, standatrTypeStudyGroup);
}
catch (Exception ex)
{
//assert
exception = ex.GetType();
}
finally
{
Assert.AreEqual(result, exception);
}
}
public async Task <Group.Group> LoadGroupAsync()
{
var result = new Group.Group();
try
{
var loadedGroup = await GetDataAsync(GroupURL);
result.Name = loadedGroup["name"].ToString();
result.Description = HtmlFormatter.RemoveHtmlTags(loadedGroup["description"].ToString());
result.City = loadedGroup["city"].ToString();
result.ImageUrl = loadedGroup["group_photo"]["photo_link"].ToString();
return(result);
}
catch (Exception ex)
{
LogException(ex);
}
return(result);
}
/// <summary>
/// getPrice(gr, csDP, priceStr) - return price made from priceStr in price-list as set in csDP price type
/// </summary>
/// <param name="group">element group to be priced</param>
/// <param name="csDP">CompSet Dictionary of Parameters</param>
/// <param name="priceStr">price string in price-list</param>
/// <returns>double price value, converted from priceStr, group of elemetsa, and pricing type</returns>
private double getPrice(Group.Group group, DPar.DPar csDP, string priceStr)
{
double price = Lib.ToDouble(priceStr);
foreach (var sec in csDP.dpar)
{
if (!sec.Key.ToString().Contains("UNIT_")) continue;
switch (sec.Key)
{
case SType.UNIT_Weight: // kg -> tonn
if (group.totalWeight == 0) return group.totalVolume * 7850;
return group.totalWeight / 1000 * price;
case SType.UNIT_Vol: // NO mm3 -> m3
return group.totalVolume * price;
// return group.totalVolume / 1000 / 1000 / 1000 * price;
case SType.UNIT_Length:
return group.totalLength * price;
case SType.UNIT_Qty:
return price;
}
}
return 0;
}
public virtual Group.Group UpdateGroup(HttpContext context)
{
YZRequest request = new YZRequest(context);
int groupid = request.GetInt32("groupid");
JObject jPost = request.GetPostData <JObject>();
Group.Group groupPost = jPost["data"].ToObject <Group.Group>();
using (IYZDbProvider provider = YZDbProviderManager.DefaultProvider)
{
using (IDbConnection cn = provider.OpenConnection())
{
Group.Group group = GroupManager.GetGroup(provider, cn, groupid);
group.ImageFileID = groupPost.ImageFileID;
group.Name = groupPost.Name;
group.Desc = groupPost.Desc;
GroupManager.Update(provider, cn, group);
return(group);
}
}
}
bool isMatchGrRule(SType stype, Group.Group gr, Rule.Rule rule)
{
if (rule == null || !compDP.dpar.ContainsKey(stype))
{
return(true);
}
string sb = new Sec(rule.text, stype).body;
if (sb == "")
{
return(true);
}
var ruleSyns = rule.synonyms;
string comMatPrf = viewComp_(stype);
string grMatPrf = stype == SType.Material ? gr.mat : gr.prf;
if (ruleSyns != null && ruleSyns.ContainsKey(stype))
{
List <string> Syns = ruleSyns[stype].ToList();
if (!Lib.IContains(Syns, comMatPrf) || !Lib.IContains(Syns, grMatPrf))
{
return(false);
}
string c = strExclude(comMatPrf, Syns);
string g = strExclude(grMatPrf, Syns);
if (c == g)
{
return(true);
}
string pattern = new Sec(rule.text, stype).body.Replace("=", "");
foreach (var s in Syns)
{
pattern = strExclude(pattern, Syns);
}
return(isOK(pattern, c, g));
}
return(comMatPrf == grMatPrf);
}
/// <summary>
/// Mtch(gr, _rule) - check if Group gr is in match with rule
/// if Mtch.ok.Match - return Mtch.Component chousen from CompSet.Component
/// else ok.NoMatch
/// </summary>
/// <param name="gr"></param>
/// <param name="_rule"></param>
public Mtch(Group.Group gr, Rule.Rule _rule)
{
if (gr == null || gr.guids == null || gr.guids.Count < 1)
Msg.F("Matcher__Mtch Bad arguments");
ok = OK.NoMatch;
group = gr;
foreach (var comp in _rule.CompSet.Components)
{
bool found = false;
try { found = comp.isMatch(gr, _rule); }
catch { }
if (!found) continue;
//-- Component is found - fill Price for all Guids elemets
ok = OK.Match;
string priceStr;
try { priceStr = comp.Str(SType.Price); }
catch { Msg.F("Match: Bad Price descriptor", _rule.sSupl, _rule.sCS); }
component = comp;
//29/8 gr.match = this; //27/3!!
rule = _rule;
gr.totalPrice = getPrice(gr, rule.CompSet.csDP, comp.Str(SType.Price));
break;
}
}
public Task <GroupProject> CreateAsync(Group.Group group, Project.Project project)
{
return(System.Threading.Tasks.Task.Factory.StartNew(() => new GroupProject(group, project)));
}
protected virtual void PostProcessNotifyTopic(IYZDbProvider provider, IDbConnection cn, BPMConnection bpmcn, string loginUserAccount, DataRow row, bool countUsers)
{
JObject jExt = new JObject();
row["ext"] = jExt;
YZResourceType resType = (YZResourceType)Enum.Parse(typeof(YZResourceType), Convert.ToString(row["resType"]), true);
row["resType"] = resType.ToString();
if (row.Table.Columns.Contains("uid"))
{
string uid = Convert.ToString(row["uid"]);
User user = User.TryGetUser(bpmcn, uid);
jExt["UserShortName"] = user == null ? uid : user.ShortName;
}
switch (resType)
{
case YZResourceType.Task:
BPMTask task = BPMTask.Load(bpmcn, Int32.Parse(Convert.ToString(row["resId"])));
ProcessProperty property = BPMProcess.GetProcessProperty(bpmcn, task.ProcessName, task.ProcessVersion);
string owner = YZStringHelper.GetUserShortName(task.OwnerAccount, task.OwnerDisplayName);
row["resName"] = String.Format(Resources.YZStrings.All_BPM_Task_Title_FMT, owner, task.ProcessName);
jExt["ProcessName"] = task.ProcessName;
jExt["Owner"] = owner;
jExt["Color"] = property.Color;
jExt["ShortName"] = property.ShortName;
if (String.IsNullOrEmpty(property.ShortName))
{
jExt["ShortName"] = YZStringHelper.GetProcessDefaultShortName(task.ProcessName);
}
break;
case YZResourceType.Group:
Group.Group group = GroupManager.GetGroup(provider, cn, Int32.Parse(Convert.ToString(row["resId"])));
row["resName"] = group.Name;
jExt["GroupType"] = group.GroupType;
jExt["ImageFileID"] = group.ImageFileID;
if (countUsers)
{
jExt["MemberCount"] = GroupManager.GetGroupMemberCount(provider, cn, group.GroupID);
}
break;
case YZResourceType.SingleChat:
P2PGroup.P2PGroup p2pGroup = P2PGroupManager.GetGroup(provider, cn, Int32.Parse(Convert.ToString(row["resId"])));
row["resName"] = p2pGroup.GetGroupName(bpmcn, loginUserAccount);
jExt["P2PPeerAccount"] = p2pGroup.GetPeerAccount(loginUserAccount);
jExt["FolderID"] = p2pGroup.FolderID;
break;
case YZResourceType.TaskApproved:
row["resName"] = Resources.YZStrings.Aspx_Message_Title_Approved;
break;
case YZResourceType.TaskRejected:
row["resName"] = Resources.YZStrings.Aspx_Message_Title_Rejected;
break;
default:
break;
}
}
static void Main()
{
Console.WriteLine("Begin");
//Gender.Gender gender = new Gender.Gender("мужской");
//var genders = new List<Gender.Gender>
//{
// new Gender.Gender("мужской"),
// new Gender.Gender("женский"),
//};
ClassRoom.ClassRoom classRoom = new ClassRoom.ClassRoom("Аудит1", 101);
var classRooms = new List <ClassRoom.ClassRoom>
{
new ClassRoom.ClassRoom("Аудит1", 50),
new ClassRoom.ClassRoom("Аудит2", 34),
new ClassRoom.ClassRoom("Аудит3", 45),
new ClassRoom.ClassRoom("Аудит4", 107),
new ClassRoom.ClassRoom("Аудит5", 31),
};
Group.Group group = new Group.Group("TBO", 2, "TBO-2", Interface.Interface.TypeStudy.FullTimeEducation, 35);
var groups = new List <Group.Group>
{
new Group.Group("TBO", 1, "TBO-1", Interface.Interface.TypeStudy.FullTimeEducation, 35),
new Group.Group("TBO", 2, "TBO-2", Interface.Interface.TypeStudy.FullTimeEducation, 25),
new Group.Group("TMO", 3, "TMO-3", Interface.Interface.TypeStudy.FullTimeEducation, 11),
new Group.Group("TCO", 2, "TCO-2", Interface.Interface.TypeStudy.FullTimeEducation, 54),
};
Subject.Subject subject = new Subject.Subject("Математика");
var subjects = new List <Subject.Subject>
{
new Subject.Subject("программирование 2 курс"),
new Subject.Subject("математический анализ 3 курс"),
new Subject.Subject("введение в специальность 1 курс"),
new Subject.Subject("история России 1-4 курс"),
};
NumberOfLesson.NumberOfLesson numberOfLesson = new NumberOfLesson.NumberOfLesson(subject, 5);
var numberOfLessons = new List <NumberOfLesson.NumberOfLesson> [groups.Count];
for (int i = 0; i < groups.Count; i++)
{
int r1 = i * 5 % subjects.Count;
int r2 = i * 3 % subjects.Count;
if (r1 == r2)
{
r1 = (r1 + 1) % subjects.Count;
}
var tempNumberOfLessons = new List <NumberOfLesson.NumberOfLesson>
{
new NumberOfLesson.NumberOfLesson(subjects[r1], 7),
new NumberOfLesson.NumberOfLesson(subjects[r2], 9),
};
numberOfLessons[i] = tempNumberOfLessons;
}
;
Semester.Semester semester = new Semester.Semester(new DateTime(2019, 02, 02), new DateTime(2019, 05, 31));
DaysOfStudy.DaysOfStudy daysOfStudy = new DaysOfStudy.DaysOfStudy(DateTime.Now, Interface.Interface.HowDays.DayOff);
Person.Person person = new Person.Person("Dima", Interface.Interface.Gender.men, new DateTime(1996, 05, 19), "Юго западная");
SubjectOfTeacher.SubjectOfTeacher subjectOfTeacher = new SubjectOfTeacher.SubjectOfTeacher(subject, 10);
Teacher.Teacher teacher = new Teacher.Teacher(new List <SubjectOfTeacher.Interfaces.ISubjectOfTeacherWithConsole> {
subjectOfTeacher
}, "none", 1, person);
var teachers = new List <Teacher.Teacher>();
string[] names = { "Александр", "Максим", "Виктор", "Дмитрий", "Олег" };
for (int i = 0; i < 5; i++)
{
int r1 = i * 5 % subjects.Count;
int r2 = i * 3 % subjects.Count;
if (r1 == r2)
{
r1 = (r1 + 1) % subjects.Count;
}
var subjectOfTeacher1 = new List <SubjectOfTeacher.Interfaces.ISubjectOfTeacherWithConsole>
{
new SubjectOfTeacher.SubjectOfTeacher(subjects[r1], 100),
new SubjectOfTeacher.SubjectOfTeacher(subjects[r2], 100),
};
var person1 = new Person.Person(names[i], genders[0], new DateTime(1958 + i, (17 * i) % 12 + 1, (23 * i) % 28 + 1), "Not info");
var teacher1 = new Teacher.Teacher(subjectOfTeacher1, "none", 1, person1);
teachers.Add(teacher1);
}
TimeLessons.TimeLessons timeLessons = new TimeLessons.TimeLessons(new TimeSpan(09, 00, 00), new TimeSpan(10, 30, 00), 1);
var timeLessonss = new List <TimeLessons.TimeLessons>
{
new TimeLessons.TimeLessons(new TimeSpan(09, 00, 00), new TimeSpan(10, 30, 00), 1),
new TimeLessons.TimeLessons(new TimeSpan(10, 40, 00), new TimeSpan(12, 10, 00), 2),
new TimeLessons.TimeLessons(new TimeSpan(13, 00, 00), new TimeSpan(14, 30, 00), 3),
new TimeLessons.TimeLessons(new TimeSpan(14, 40, 00), new TimeSpan(16, 10, 00), 4),
new TimeLessons.TimeLessons(new TimeSpan(16, 20, 00), new TimeSpan(17, 50, 00), 5),
new TimeLessons.TimeLessons(new TimeSpan(18, 00, 00), new TimeSpan(19, 30, 00), 6),
};
TypeLessons.TypeLessons typeLessons = new TypeLessons.TypeLessons("Лекция");
var typeLessonss = new List <TypeLessons.TypeLessons>
{
new TypeLessons.TypeLessons("Лекция"),
new TypeLessons.TypeLessons("Практика"),
};
Console.WriteLine("Вы вышли в основную программу!");
Console.ReadLine();
}
public virtual Group.Group ProvisionGroup(string name, string description)
{
AssertionConcern.True(this.Active, "Tenant is not active.");
Group.Group group = new Group.Group(this.TenantId, name, description);
DomainEventPublisher.Instance.Publish(new GroupProvisioned(this.TenantId, name));
return group;
}
/// <summary>
/// Copy constructor
/// </summary>
/// <param name="group"></param>
public GroupViewModel(Group.Group group) : this(group.GroupId, group.Ident, group.Name, group.IsDefaultGroup)
{
}
public virtual Group.Group CreateGroup(HttpContext context)
{
YZRequest request = new YZRequest(context);
string groupType = request.GetString("groupType");
string FolderID = request.GetString("FolderID", null);
string DocumentFolderID = request.GetString("DocumentFolderID", null);
JObject jPost = request.GetPostData <JObject>();
Group.Group groupPost = jPost["data"].ToObject <Group.Group>();
BPMObjectNameCollection uids = new BPMObjectNameCollection();
if (jPost["uids"] != null)
{
uids = jPost["uids"].ToObject <BPMObjectNameCollection>();
}
using (IYZDbProvider provider = YZDbProviderManager.DefaultProvider)
{
using (IDbConnection cn = provider.OpenConnection())
{
Group.Group group = new Group.Group();
group.GroupType = groupType;
group.Name = groupPost.Name;
group.Desc = groupPost.Desc;
if (!String.IsNullOrEmpty(FolderID))
{
Folder folder = this.CreateGroupFolder(provider, cn, groupPost.Name, FolderID);
group.FolderID = folder.FolderID;
}
if (!String.IsNullOrEmpty(DocumentFolderID))
{
Folder folder = this.CreateGroupFolder(provider, cn, groupPost.Name, DocumentFolderID);
group.DocumentFolderID = folder.FolderID;
}
group.Owner = YZAuthHelper.LoginUserAccount;
group.CreateAt = DateTime.Now;
group.ImageFileID = groupPost.ImageFileID;
group.Deleted = false;
GroupManager.Insert(provider, cn, group);
YZSoft.Group.Member member;
member = new YZSoft.Group.Member();
member.GroupID = group.GroupID;
member.UID = YZAuthHelper.LoginUserAccount;
member.Role = "Owner";
GroupManager.Insert(provider, cn, member);
foreach (string uid in uids)
{
member = new YZSoft.Group.Member();
member.GroupID = group.GroupID;
member.UID = uid;
member.Role = "Member";
GroupManager.Insert(provider, cn, member);
}
return(group);
}
}
}
public GroupProject(Group.Group group, Project.Project project)
{
Group = group;
Project = project;
}
