public void Get_all_students_by_class_test()
{
var repo = new StudentRepository(this.context);
var classRepo = new ClassRepository(context);
var clazz = new ClassEntity("GR1");
var clazz2 = new ClassEntity("GR2");
classRepo.AddNew(clazz);
classRepo.AddNew(clazz2);
var model = new StudentEntity("Aneta", "Dams", clazz, true);
var model2 = new StudentEntity("Mateusz", "Brzeziński", clazz, false);
var model3 = new StudentEntity("Joanna", "Kowalska", clazz2, true);
repo.AddNew(model);
repo.AddNew(model2);
repo.AddNew(model3);
var result = repo.GetAllByClass(clazz.Id);
Assert.IsNotNull(result);
Assert.AreEqual(2, result.Count);
Assert.AreEqual(clazz.Id, result[0].Class.Id);
Assert.AreEqual(clazz.Id, result[1].Class.Id);
Assert.AreEqual(model2.Id, result[0].Id);
Assert.AreEqual(model.Id, result[1].Id);
}
void MainWindow_OnLoaded(object sender, RoutedEventArgs e)
{
var path = @"C:\Dev\vs2015\xamlpowertoys2015\XamlPowerToys.Fakes\bin\Debug\XamlPowerToys.Fakes.dll";
var resolver = new DefaultAssemblyResolver();
resolver.AddSearchDirectory(System.IO.Path.GetDirectoryName(path));
var reader = new ReaderParameters {
AssemblyResolver = resolver
};
var assemblyDefinition = AssemblyDefinition.ReadAssembly(path, reader);
var typeDefinition = assemblyDefinition.MainModule.GetType("XamlPowerToys.Fakes.People.PersonEditorViewModel");
//var typeDefinition = assemblyDefinition.MainModule.GetType("XamlPowerToys.Fakes.Books.BooksDetailPageViewModel");
var classEntity = new ClassEntity(assemblyDefinition, typeDefinition, ProjectType.Xamarin, "");
LoadPropertyInformation(assemblyDefinition, typeDefinition, classEntity);
var emptyConverterList = new List <String>();
var vm = new CreateFormViewModel(classEntity, emptyConverterList);
var view = new CreateFormView();
this.DataContext = vm;
this.rootGrid.Children.Add(view);
}
public ClassEntity Update(UserEntity userEntity, Guid ClassId, ClassEntity classEntity)
{
Class Class = context.Classes.Include(c => c.StudentClasses).Include(s => s.VersionSurvey).FirstOrDefault(c => c.Id == ClassId);
if (Class == null)
{
throw new NotFoundException("Class not found!");
}
Class updateClass = new Class(classEntity);
updateClass.CopyTo(Class);
context.SaveChanges();
List <StudentClass> studentClasses = context.StudentClasses.Include(f => f.Forms).Where(sc => sc.ClassId == ClassId).ToList();
List <StudentClass> Insert, Update, Delete;
List <StudentClass> newStudentClasses = classEntity.StudentClasses == null
? new List <StudentClass>()
: classEntity.StudentClasses.Select(sc => new StudentClass(sc)).ToList();
Common <StudentClass> .Split(newStudentClasses, studentClasses, out Insert, out Update, out Delete);
if (Insert != null)
{
foreach (var sc in Insert)
{
sc.Id = Guid.NewGuid();
sc.ClassId = Class.Id;
studentClasses.Add(sc);
context.StudentClasses.Add(sc);
}
}
if (Update != null)
{
foreach (var sc in Update)
{
var curStudentClass = studentClasses.FirstOrDefault(s => s.Id == sc.Id);
Common <StudentClass> .Copy(sc, curStudentClass);
}
}
if (Delete != null)
{
foreach (var sc in Delete)
{
var deleteStudentClass = studentClasses.FirstOrDefault(s => sc.Id == s.Id);
foreach (var form in deleteStudentClass.Forms)
{
context.Forms.Remove(form);
}
studentClasses.Remove(sc);
context.SaveChanges();
context.StudentClasses.Remove(deleteStudentClass);
}
}
context.SaveChanges();
return(new ClassEntity(Class));
}
public void Get_timetable_by_id_test()
{
var repo = new TimeTableRepository(context);
var classRepo = new ClassRepository(context);
var subjectRepo = new SubjectRepository(context);
ClassEntity clazz = new ClassEntity("GR1");
classRepo.AddNew(clazz);
SubjectEntity subject = new SubjectEntity("AM", "Analiza");
subjectRepo.AddNew(subject);
TimeTableEntity model = new TimeTableEntity("poniedziałek", clazz, subject);
TimeTableEntity model2 = new TimeTableEntity("wtorek", clazz, subject);
repo.AddNew(model);
repo.AddNew(model2);
var result = repo.GetById(2);
Assert.IsNotNull(result);
Assert.AreEqual(2, result.Id);
Assert.AreEqual(model2.Class.Id, result.Class.Id);
Assert.AreEqual(model2.Subject.Id, result.Subject.Id);
Assert.AreEqual(model2.Day, result.Day);
}
private void cboEntity_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (e.AddedItems == null)
{
return;
}
ClassEntity clEntity = e.AddedItems[0] as ClassEntity;
ucProduct.Visibility = Visibility.Collapsed;
ucBin.Visibility = Visibility.Collapsed;
ucProduct.Product = null;
ucBin.Bin = null;
switch (clEntity.ClassEntityID)
{
case EntityID.Product:
ucProduct.Visibility = Visibility.Visible;
break;
case EntityID.Bin:
ucBin.Visibility = Visibility.Visible;
break;
}
}
/// <summary>
/// Initializes a new instance of the FieldsListWindow class.
/// </summary>
/// <param name="ClassEntity">
/// The class entity.
/// </param>
public FieldsListWindow(ClassEntity ClassEntity)
{
this.InitializeComponent();
// Add other initialization code here
this._classEntity = ClassEntity;
}
/// <summary>
///
/// </summary>
/// <param name="info"></param>
/// <returns></returns>
/// <remarks>Need to change returned UnknownEntity's Value.</remarks>
private IEntity CreateOrdinalEntity(string word, FullLemmaInfo info)
{
if (!this.GramTable.ContainsKey(info.CommonMF.Gramcode))
{
throw new Exception("Gramcode error");
}
if (info == FullLemmaInfo.Unknown)
{
return(null);
}
IEntity result = null;
PartOfSpeech pos = this.GramTable[info.CommonMF.Gramcode].PartOfSpeech;
if (pos == PartOfSpeech.Noun)
{
result = new ClassEntity(info.CommonLemma);
}
else if (pos == PartOfSpeech.Adjective ||
pos == PartOfSpeech.AdjectiveFull ||
pos == PartOfSpeech.AdjectiveShort)
{
result = new PropertyEntity(info.CommonLemma);
}
else
{
result = new UnknownEntity(info.CommonLemma);
}
result.PartOfSpeech = pos;
return(result);
}
private void SetValuesInFields(ClassEntity entityClass)
{
this.idClass.Text = entityClass.Id.ToString();
this.txtLocal.Text = entityClass.Local;
this.txtNameClass.Text = entityClass.Name;
this.txtValueClass.Text = entityClass.ValueCourse.ToString();
this.dtpDtInicial.Value = entityClass.StartDate;
this.dtpDtFinal.Value = entityClass.FinishDate;
this.cbTypeClass.SelectedIndex = this.cbTypeClass.FindString(entityClass.Type);
this.dgvListLessons.DataSource = (from cl in new ClassLessonsBUS().GetAll()
join l in new LessonsBUS().GetAll() on cl.IdLessons equals l.Id
where cl.IdClass == entityClass.Id
select new {
Nome = l.Name,
Tipo = l.Type,
Codigo = l.Id,
Data = l.DateLesson
}).ToList();
this.dgvListLessons.Columns[2].HeaderText = "Código";
this.dgvListLessons.Columns[0].HeaderText = "Nome";
this.dgvListLessons.Columns[0].MinimumWidth = 250;
this.dgvListLessons.Columns[1].HeaderText = "Tipo";
this.dgvListLessons.Columns[3].HeaderText = "Data Aula";
}
private void AddOneRecord(Object record)
{
if (record == null)
{
return;
}
// entidad Base seleccionada
ClassEntity entitySel = View.ClassEntityCmb.SelectedItem as ClassEntity;
if (entitySel == null)
{
return;
}
try
{
int entityRowId = 0;
switch (entitySel.Name)
{
case "Account":
entityRowId = ((Account)record).AccountID;
// el registro ya existe en la lista destino?
if (View.CriteriaListReg.ItemsSource.Cast <Account>().Where(f => f.AccountID == entityRowId).Count() != 0)
{
return;
}
break;
case "Product":
entityRowId = ((Product)record).ProductID;
// el registro ya existe en la lista destino?
if (View.CriteriaListReg.ItemsSource.Cast <Product>().Where(f => f.ProductID == entityRowId).Count() != 0)
{
return;
}
break;
default: break;
}
ZoneEntityRelation zoneEnt = new ZoneEntityRelation
{
Zone = View.Model.Record,
Entity = entitySel,
Rank = 0,
EntityRowID = entityRowId,
CreatedBy = App.curUser.UserName,
CreationDate = DateTime.Today
};
service.SaveZoneEntityRelation(zoneEnt);
//View.CriteriaListReg.Items.Add(record);
//View.CriteriaList.Items.Remove(record);
}
catch (Exception ex)
{
throw ex;
}
}
private IList <Result> GetResults(ClassEntity classContract, ResultRepository resultRepository)
{
if (classContract.NoTimePresentation)
{
var results = resultRepository.Get(_eventRaceId, _eventId, classContract.Id);
var resultContracts = results.ToContractsWithoutTimes();
return(resultContracts);
}
else
{
var results = resultRepository.GetWithSplitTimes(_eventRaceId, _eventId, classContract.Id);
IList <Result> resultContracts;
if (classContract.Courses.Count == 1 && classContract.Courses.Single().SplitControls.Count > 0)
{
resultContracts = results.ToContractsWithSplitTimes(classContract.Courses.Single());
}
else
{
resultContracts = results.ToContracts();
}
if (!classContract.NoTimePresentation)
{
resultContracts = ResultOrderer.OrderByStatusAndTime(resultContracts);
resultContracts = OrdinalCalculator.AddOrdinal(resultContracts);
resultContracts = ResultOrderer.OrderBySplitTimes(resultContracts);
}
return(resultContracts);
}
}
public ActionResult GetPageListJson(Pagination pagination, string queryJson)
{
var watch = CommonHelper.TimerStart();
ClassEntity para = new ClassEntity();
if (!string.IsNullOrWhiteSpace(queryJson))
{
var queryParam = queryJson.ToJObject();
//类型
if (!queryParam["condition"].IsEmpty() && !queryParam["keyword"].IsEmpty())
{
var condition = queryParam["condition"].ToString().ToLower();
switch (condition)
{
case "classname":
para.ClassName = queryParam["keyword"].ToString();
break;
}
}
}
var pageList = ClassBLL.Instance.GetPageList(para, ref pagination);
var JsonData = new
{
rows = pageList,
total = pagination.total,
page = pagination.page,
records = pagination.records,
costtime = CommonHelper.TimerEnd(watch)
};
return(Content(JsonData.ToJson()));
}
public async Task <IHttpActionResult> PutClassEntity(Guid id, ClassEntity classEntity)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
classEntity.ID = id;
db.Entry(classEntity).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ClassEntityExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public void Add_new_class_test()
{
var repo = new ClassRepository(context);
var model = new ClassEntity("GR1");
repo.AddNew(model);
}
public void Get_presences_by_student_and_subject_test()
{
var repo = new PresenceRepository(this.context);
var studrepo = new StudentRepository(this.context);
var timerepo = new TimeTableRepository(this.context);
var classrepo = new ClassRepository(this.context);
var subrepo = new SubjectRepository(this.context);
ClassEntity clazz = new ClassEntity("GR1");
classrepo.AddNew(clazz);
StudentEntity model = new StudentEntity("Aneta", "Dams", clazz, true);
studrepo.AddNew(model);
SubjectEntity subject = new SubjectEntity("AM", "Analiza Matematyczna");
subrepo.AddNew(subject);
TimeTableEntity timeTable = new TimeTableEntity("poniedziałek", clazz, subject);
var model1 = new PresenceEntity(model, subject, DateTime.Now.Date, true);
var model2 = new PresenceEntity(model, subject, DateTime.Now.Date.AddDays(2), true);
repo.AddNew(model1);
repo.AddNew(model2);
var result = repo.GetAllByStudentAndSubject(model.Id, subject.Id);
Assert.IsNotNull(result);
Assert.AreEqual(2, result.Count);
Assert.AreEqual(model1.Id, result[0].Id);
Assert.AreEqual(model2.Id, result[1].Id);
}
public async Task <IHttpActionResult> PostClassEntity(ClassEntity classEntity)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.ClassEntities.Add(classEntity);
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (ClassEntityExists(classEntity.ID))
{
return(Conflict());
}
else
{
throw;
}
}
return(Ok(classEntity.ID)); //CreatedAtRoute("DefaultApi", new { id = classEntity.ID }, classEntity);
}
private void GenerateClassEntity(String baseFolder, IList <FrameworkEntity> entities, Framework f, FrameworkEntity e, String sourcePath, String destinationPath)
{
String file;
ClassEntity entity = BaseEntity.LoadFrom <ClassEntity> (sourcePath);
// Make sure that availability is ready
entity.AdjustAvailability();
this.Log(Level.Info, String.Format("Generating '{0}'...", e.name));
this.LoadClassDependencies(baseFolder, entities, entity);
if (entity.ExtendedClass == null)
{
if (entity.Generate)
{
file = destinationPath + ".cs";
this.Generate <ClassDefinitionGenerator>(f, entity, file);
}
if (entity.Generate)
{
file = destinationPath + ".Class.cs";
this.Generate <ClassMembersGenerator>(f, entity, file);
}
if (entity.Generate && entity.HasConstructors)
{
file = destinationPath + ".Constructors.cs";
this.Generate <ClassConstructorsGenerator> (f, entity, file);
}
if (entity.HasConstants || entity.HasEnumerations)
{
file = destinationPath + ".Constants.cs";
this.Generate <ClassConstantsGenerator> (f, entity, file);
}
if (entity.Generate && entity.Protocols != null && entity.Protocols.Count > 0)
{
file = destinationPath + ".Protocols.cs";
this.Generate <ClassProtocolsGenerator> (f, entity, file);
}
}
else
{
if (entity.Generate)
{
file = destinationPath + ".cs";
this.Generate <ClassAdditionsGenerator>(f, entity, file);
}
if (entity.HasConstants || entity.HasEnumerations)
{
file = destinationPath + ".Constants.cs";
this.Generate <ClassConstantsGenerator> (f, entity, file);
}
}
}
private static string GetExtraParameter(ClassEntity classEntity, MethodEntity methodEntity, bool extension)
{
if (extension && !methodEntity.Static)
{
return(String.Format("this {0} __target", classEntity.Name));
}
return(String.Empty);
}
public void ChangeClassTeacherBelong(int id, int newTeacherId)
{
ClassEntity classEntity = icf.SelectClass(id);
icf.DeleteClassById(id);
classEntity.teacherId = newTeacherId;
icf.AddClass(classEntity);
}
public void Process(ClassEntity classEntity)
{
if (classEntity.NamespaceEntity.FormattedName == "Runtime" && classEntity.FormattedName == "Port")
{
// Remove this postMessage function because it has no parameter, so we define it in Extensions/Runtime/Port
classEntity.Properties.Remove("postMessage");
}
}
public void TranslateClassEntityToCodeFile(ClassEntity classEntity, CodeFile codeFile)
{
foreach (var relativeNamespace in classEntity.UsingRelativeNamespaces)
{
codeFile.UsingRelativeNamespaces.Add(relativeNamespace);
}
GetFactory(classEntity).AddConvertersToCodeFile(classEntity, codeFile);
}
public void ChangeClassName(int id, string newName)
{
ClassEntity classEntity = icf.SelectClass(id);
icf.DeleteClassById(id);
classEntity.name = newName;
icf.AddClass(classEntity);
}
private IEnumerable <CodeFileConverter> GetClassEntityCodeConverters(ClassEntity classEntity)
{
if (classEntity.ImplementInterface)
{
yield return(GetClassEntityInterfaceCodeConverter(classEntity));
}
yield return(GetClassEntityCodeConverter(classEntity));
}
public bool AddClass(ClassEntity classEntity)
{
using (var db = new EntityContext())
{
db.Add(classEntity);
db.SaveChanges();
return(true);
}
}
protected void Page_Load(object sender, EventArgs e)
{
var secId = int.Parse(Request.QueryString["secId"]);
var section = SectionEntity.GetSection(secId);
var mClass = ClassEntity.GetClass(section.ClassId);
this.threadHeader.Text = mClass.ClassName + " - " + section.SectionName;
}
public void Add_new_class_test()
{
// this.SetupAll();
var repo = new ClassRepository(connString);
var model = new ClassEntity("GR1");
repo.AddNew(model);
}
/// <summary>
/// Initializes a new instance of the FieldsListWindow class.
/// </summary>
/// <param name="ClassEntity">
/// The class entity.
/// </param>
public FieldsListWindow(ClassEntity ClassEntity)
{
logger.Trace("Entered FieldsListWindow()");
this.InitializeComponent();
// Add other initialization code here
this._classEntity = ClassEntity;
}
public static CompetitionClass ToContract(this ClassEntity entity)
{
return(new CompetitionClass {
Id = entity.Id,
ShortName = entity.ShortName,
NoTimePresentation = entity.NoTimePresentation,
SplitControls = ToContract(entity.Courses),
});
}
private CodeFileConverter GetClassEntityInterfaceCodeConverter(ClassEntity classEntity)
{
var relativeNamespace = classEntity.NamespaceEntity.FormattedName;
var declaration = $"public interface I{classEntity.FormattedName}";
var codeFile = new CodeFile($"I{classEntity.FormattedName}", relativeNamespace, declaration);
classEntityTranslator.TranslateClassEntityToInterfaceCodeFile(classEntity, codeFile);
return(new CodeFileConverter(codeFile));
}
/// <summary>
/// Generates the specified entity.
/// </summary>
/// <param name = "entity">The entity.</param>
public override void Generate(BaseEntity entity)
{
ClassEntity classEntity = (ClassEntity)entity;
ClassEntity extendedClass = classEntity.ExtendedClass ?? classEntity;
bool sameClass = String.Equals(classEntity.Namespace, extendedClass.Namespace);
// Append License
this.Writer.WriteLineFormat(0, License);
// Append usings
this.AppendStandardNamespaces();
// Append namespace starter
this.Writer.WriteLineFormat(0, "namespace Monobjc.{0}", classEntity.Namespace);
this.Writer.WriteLineFormat(0, "{{");
if (classEntity.Constants.Count > 0)
{
// Append static condition if needed
this.AppendStartCondition(classEntity);
// Append class starter
if (sameClass)
{
this.Writer.WriteLineFormat(1, "public partial class {0}", extendedClass.Name);
}
else
{
this.Writer.WriteLineFormat(1, "public static partial class {0}_{1}Additions", extendedClass.Name, classEntity.Namespace);
}
this.Writer.WriteLineFormat(1, "{{");
// Output the constants
foreach (ConstantEntity constantEntity in classEntity.Constants.Where(e => e.Generate))
{
this.ConstantGenerator.Generate(classEntity, constantEntity);
this.Writer.WriteLine();
}
// Append class ender
this.Writer.WriteLineFormat(1, "}}");
// Append static condition if needed
this.AppendEndCondition(classEntity);
}
// Output the enumerations
foreach (EnumerationEntity enumerationEntity in classEntity.Enumerations)
{
this.Writer.WriteLine();
this.EnumerationGenerator.Generate(enumerationEntity, false);
}
// Append namespace ender
this.Writer.WriteLineFormat(0, "}}");
}
/// <summary>
/// Gets the properties of the superclass and own.
/// </summary>
protected static IEnumerable <PropertyEntity> GetProperties(ClassEntity classEntity, bool withOwn)
{
List <PropertyEntity> properties = (classEntity.SuperClass != null) ? classEntity.SuperClass.GetProperties(true, true).ToList() : new List <PropertyEntity> ();
if (withOwn)
{
properties.AddRange(classEntity.Properties);
}
return(properties.Distinct());
}
public void DeleteClassEntity(ClassEntity data)
{
try {
SetService(); SerClient.DeleteClassEntity(data); }
finally
{
SerClient.Close();
if (SerClient.State == CommunicationState.Faulted)
SerClient.Abort();
}
}
public ClassEntity SaveClassEntity(ClassEntity data)
{
try {
SetService(); return SerClient.SaveClassEntity(data); }
finally
{
SerClient.Close();
if (SerClient.State == CommunicationState.Faulted)
SerClient.Abort();
}
}
