private static void PlayIncremental(long[,,] times, int n, int sizeIdx, int iteration, Stopwatch watch, InputModelContainer inputModelContainer, OutputModelContainer outputModelContainer, List <MakeWorkloadAction> workload)
{
var outputRepository = new ModelRepository();
Directory.CreateDirectory("makeOutputModelsIncSync");
Directory.CreateDirectory("makeOutputModelsIncSync\\" + n);
Directory.CreateDirectory("makeOutputModelsIncSync\\" + n + "\\" + iteration);
Make2Ant.InputModelContainer = inputModelContainer;
Make2Ant.OutputModelContainer = outputModelContainer;
watch.Restart();
for (int index = 0; index < workload.Count; index++)
{
var item = workload[index];
item.Perform(inputModelContainer.IN);
var tempRepo = new ModelRepository();
tempRepo.Resolve("makeInputModelsSync\\" + n + "\\" + iteration + "\\" + "inputModel" + index + ".xmi");
outputRepository.Save(outputModelContainer.OUT, "makeOutputModelsIncSync\\" + n + "\\" + iteration + "\\" + "outputModel" + index + ".xmi");
}
watch.Stop();
Directory.Delete("makeOutputModelsIncSync", true);
times[sizeIdx, iteration, 3] = watch.Elapsed.Ticks * 100;
}
private void DisplyChildObjects(string rootNodeHader, TreeViewItem currentObjectTreeViewItem,
TSqlObject currentObject, Dictionary <string, TreeViewItem> childObjectTypes)
{
var children = currentObject.GetChildren();
foreach (var child in children.OrderBy(p => p, new SqlObjectComparer()))
{
var type = child.ObjectType.Name;
var typeContainerHeader = GetContainerHeader(type);
if (!childObjectTypes.ContainsKey(typeContainerHeader))
{
var item = AddTreeItem(typeContainerHeader, currentObjectTreeViewItem, _defaultForeground);
childObjectTypes.Add(typeContainerHeader, item);
}
var childTreeViewItem = AddTreeItem(child.Name.ToString(), childObjectTypes[typeContainerHeader],
_defaultForeground);
DisplayObject(rootNodeHader, child, childTreeViewItem);
}
var repository = ModelRepository.GetRepository();
if (repository.LoadScriptDom())
{
TSqlFragment fragment;
TSqlModelUtils.TryGetFragmentForAnalysis(currentObject, out fragment);
var frgPrc = new TSqlFragmentProcess.TSqlFragmentProcess(this);
frgPrc.ProcessTSQLFragment(fragment, currentObjectTreeViewItem);
}
}
public ModelForm(int id = 0)
{
InitializeComponent();
pictureBox1.Visible = false;
pictureBox2.Visible = false;
brands = BrandRepository.GetAll();
foreach (Brand b in brands)
{
brandsDropdown.Items.Add(b.Name);
}
if (id != 0)
{
this.id = id;
Model model = ModelRepository.Get(id);
modelTextBox.Text = model.Name;
brandsDropdown.Text = model.Brand.Name;
}
else
{
brandsDropdown.Text = brands.Count > 0 ? brands[0].Name : "";
}
}
public UnitOfWork(NgAppDbContext context)
{
_context = context;
Features = new FeatureRepository(_context);
Model = new ModelRepository(_context);
Make = new MakeRepository(_context);
}
public ConvertEntities(ModelRepository parent, IDiagnostic diagnostic, FileModel fullPath)
{
this._referenceSchema = fullPath.Schema;
this._parent = parent;
this._file = fullPath;
this._diagnostic = diagnostic;
}
public async Task <ActionResult> Authorize(int userId)
{
if (!LoggedInUserInfo.User.IsAdministrator())
{
return("Sólo administradores pueden autorizar acceso a usuarios.".ToJsonResult());
}
var userToAuthorize = await ModelRepository
.SingleAsync(user => user.Id == userId).ConfigureAwait(false);
if (userToAuthorize == null)
{
return("El usuario no existe.".ToJsonResult());
}
if (userToAuthorize.IsAuthorized)
{
return(userToAuthorize.ToJsonResult());
}
userToAuthorize.IsAuthorized = true;
userToAuthorize.AuthorizedByUserId = LoggedInUserInfo.User.Id;
userToAuthorize.AuthorizationDate = DateTime.Now;
await ModelRepository.UpdateAsync(userToAuthorize).ConfigureAwait(false);
return(true.ToJsonResult());
}
public Member(EmbedService embeds, IDatabase db, ModelRepository repo, HttpClient client)
{
_embeds = embeds;
_db = db;
_repo = repo;
_client = client;
}
public ReactionAdded(EmbedService embeds, ILogger logger, IDatabase db, ModelRepository repo)
{
_embeds = embeds;
_db = db;
_repo = repo;
_logger = logger.ForContext <ReactionAdded>();
}
public EmbedService(IDatabase db, ModelRepository repo, IDiscordCache cache, DiscordApiClient rest)
{
_db = db;
_repo = repo;
_cache = cache;
_rest = rest;
}
private static void PlayBatchNet(long[,,] times, int n, int sizeIdx, int iteration, Make2Ant.Model2ModelMainRule startRule, Stopwatch watch, ref InputModelContainer inputModelContainer, ref OutputModelContainer outputModelContainer, List <MakeWorkloadAction> workload)
{
var outputRepository = new ModelRepository();
Directory.CreateDirectory("makeOutputModelsBatchSync");
Directory.CreateDirectory("makeOutputModelsBatchSync\\" + n);
Directory.CreateDirectory("makeOutputModelsBatchSync\\" + n + "\\" + iteration);
Make2Ant.InputModelContainer = inputModelContainer;
Make2Ant.OutputModelContainer = outputModelContainer;
watch.Restart();
for (int index = 0; index < workload.Count; index++)
{
var item = workload[index];
item.Perform(inputModelContainer.IN);
outputModelContainer = new OutputModelContainer(new Model());
RerunBatchSynchronization(startRule, ref inputModelContainer, ref outputModelContainer);
var tempRepo = new ModelRepository();
tempRepo.Resolve("makeInputModelsSync\\" + n + "\\" + iteration + "\\" + "outputModel" + index + ".xmi");
outputRepository.Save(outputModelContainer.OUT, "makeOutputModelsBatchSync\\" + n + "\\" + iteration + "\\" + "outputModel" + index + ".xmi");
}
watch.Stop();
Directory.Delete("makeOutputModelsBatchSync", true);
times[sizeIdx, iteration, 2] = watch.Elapsed.Ticks * 100;
}
/// <summary>
/// Initializes the singleton application object. This is the first line of authored code
/// executed, and as such is the logical equivalent of main() or WinMain().
/// </summary>
public App()
{
InitializeComponent();
Suspending += OnSuspending;
Repository = new ModelRepository(new ModelLoader(), new ModelWriter(), new SimpleMemoryCache());
}
public async void Should_RequestSuccessful_Model()
{
var data = new List <Model>
{
new Model {
Name = "Onix 1.6"
},
new Model {
Name = "Onix LTE 1.6"
},
new Model {
Name = "Onix LTE 1.8"
},
}.AsQueryable();
var mockSet = new Mock <DbSet <Model> >();
mockSet.As <IQueryable <Model> >().Setup(m => m.Provider).Returns(data.Provider);
mockSet.As <IQueryable <Model> >().Setup(m => m.Expression).Returns(data.Expression);
mockSet.As <IQueryable <Model> >().Setup(m => m.ElementType).Returns(data.ElementType);
mockSet.As <IQueryable <Model> >().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
var mockContext = new Mock <IModelContext>();
mockContext.Setup(c => c.Models).Returns(mockSet.Object);
var repo = new ModelRepository(mockContext.Object);
var d = await repo.Get();
Assert.Equal(3, d.Count);
Assert.Equal("Onix 1.6", d[0].Name);
Assert.Equal("Onix LTE 1.6", d[1].Name);
Assert.Equal("Onix LTE 1.8", d[2].Name);
}
public static bool HandleCommand(Aggregate aggregate, string aggregateId, Command command)
{
string modelName = ModelNameGetter.GetModelName(aggregate.GetType());
try {
Event[] results = aggregate.execute(command);
EventStore.AppendAllEventsFor(modelName, aggregateId, results);
foreach (Event evt in results)
{
aggregate.hydrate(evt);
}
//TODO okay, good. so it looks as though each read model does indeed respond to each event.
//you can make a special read model for each character and have that in addition to the read models for each character,
//it doesn't really matter.
foreach (Reducer reducer in reducers)
{
foreach (Event evt in results)
{
reducer.Reduce(evt, ModelRepository.GetTable(reducer.ModelName));
}
}
return(true);
} catch (ValidationException e) {
Debug.Log(e.Message);
}
return(false);
}
public void Setup()
{
repository1 = new ModelRepository();
repository2 = new ModelRepository();
railway1 = LoadRailwayModel(repository1);
railway2 = LoadRailwayModel(repository2);
}
public void AddModel_With_Correct_Parameter()
{
//ARRANGE
var options = new DbContextOptionsBuilder <FleetManagmentContext>()
.UseInMemoryDatabase(databaseName: MethodBase.GetCurrentMethod().Name)
.Options;
using var context = new FleetManagmentContext(options);
IModelRepository modelRepository = new ModelRepository(context);
ModelTO model = new ModelTO
{
Name = "polo",
};
ModelTO model2 = new ModelTO
{
Name = "golf",
};
//ACT
var addedModel = modelRepository.Insert(model);
var addedModel2 = modelRepository.Insert(model2);
context.SaveChanges();
//ASSERT
Assert.IsNotNull(addedModel);
Assert.AreNotEqual(0, addedModel.Id);
Assert.AreEqual("polo", addedModel.Name);
}
/// <summary>
/// Public constructor
/// </summary>
public Benchmark()
{
Repository = new ModelRepository();
Analyzers = new List <BenchmarkJob <TRoot> >();
Log = Console.Out;
Reporting = Console.Out;
}
private void TransformChanges(string pcmModel, string changes, string target, Action <Root_MM06, Root_MM06> compareResults)
{
var repository = new ModelRepository();
var model = repository.Resolve(pcmModel + ".xmi");
var targetModel = PcmToComponentBasedSystems.Transform(model, NMF.Transformations.ChangePropagationMode.OneWay);
var targetRoot = targetModel.RootElements[0] as Root_MM06;
repository.Save(targetModel, string.Format(target, "initial"));
for (int i = 0; i < PcmChangeGenerator.NumChanges; i++)
{
var change = repository.Resolve(string.Format(changes, i)).RootElements[0] as ModelChangeSet;
var recorder = new ModelChangeRecorder();
recorder.Start(targetModel);
foreach (var subChange in change.Changes)
{
subChange.Apply();
}
recorder.Stop();
if (compareResults != null)
{
compareResults(targetRoot, PcmToComponentBasedSystems.Transform(model, NMF.Transformations.ChangePropagationMode.None).RootElements[0] as Root_MM06);
}
var targetChange = recorder.GetModelChanges();
repository.Save(targetChange, string.Format(target, i));
}
}
public void PortV3Suceeds()
{
//absolute path is needed for the execution from a junit test
var absolutePathInputModel1 = "PortV3\\SampleInput.xmi";
//load input models
var repository = new ModelRepository();
var inputModel1 = repository.Resolve(absolutePathInputModel1);
if (inputModel1 == null)
{
throw new FileNotFoundException("One of the Input Models was not found");
}
var inputModelContainer = new InputModelContainer(inputModel1);
var outputModelContainer = new OutputModelContainer();
var direction = SynchronizationDirection.LeftToRight;
var changePropagartion = ChangePropagationMode.OneWay;
var transformation = new PortV3Namespace.PortV3();
PortV3Namespace.PortV3.InputModelContainer = inputModelContainer;
var context = transformation.Synchronize(transformation.SynchronizationRule <PortV3Namespace.PortV3.Model2ModelMainRule>(), ref inputModelContainer, ref outputModelContainer, direction, changePropagartion);
}
private static void LoadStoredDevices(ModelRepository repo)
{
// If there are no current stored devices config, simply add a new DeviceCollection.
if (!File.Exists(DEVICES_CONFIG_PATH))
{
repo["devices"] = new DeviceCollection();
return;
}
Stream read;
try
{
read = new FileStream(DEVICES_CONFIG_PATH, FileMode.Open);
}
catch (Exception ex)
{
throw new IOException("Unable to load stored devices configuration.", ex);
}
try
{
repo.Deserialize("devices", typeof(iTunesAgent.Domain.DeviceCollection), read);
}
finally
{
if (read != null)
{
read.Close();
}
}
}
static void AnalyzeFrontPagePosts(string inRepoFileName)
{
ModelRepository repo = new ModelRepository();
List <string> listOfPosts = new List <string>();
Logger.Info("Opening data store: " + inRepoFileName);
repo.OpenDataStore(inRepoFileName);
Logger.Info("\nFETCHING POSTS FROM FRONTPAGE:");
for (int j = 0; j <= 500; j += 100)
{
for (int i = 85; i < 100; i++)
{
Logger.InfoFormat(" DOING FRONT PAGE - {0}", j + i);
var listPosts = FrontPageAnalyzer.GetPostLinksFromFrontPage(j + i);
listOfPosts.AddRange(listPosts);
}
}
Logger.Info("\nLIST OF POSTS TO ANALYZE:");
for (int i = 0; i < listOfPosts.Count; i++)
{
Logger.Info((i + 1).ToString() + ". " + listOfPosts[i]);
}
Logger.Info("\nSTARTING ANALYSIS:");
MultithreadedScrapper.AnalyzeListOfPosts_Multithreaded(listOfPosts, repo, true, true);
repo.UpdateDataStore();
PrintStatistics(repo);
}
public ServerConfig(LoggerCleanService cleanService, IDatabase db, ModelRepository repo, IDiscordCache cache)
{
_cleanService = cleanService;
_db = db;
_repo = repo;
_cache = cache;
}
private static void LoadApplicationConfiguration(ConfigurationChecker configurationChecker, ModelRepository repo)
{
Stream read;
try
{
configurationChecker.CheckConfiguration();
read = new FileStream(APP_CONFIG_PATH, FileMode.Open);
}
catch (Exception ex)
{
throw new IOException("Unable to load application configuration.", ex);
}
try
{
repo.Deserialize("appconfig", typeof(iTunesAgent.Domain.Configuration), read);
}
finally
{
if (read != null)
{
read.Close();
}
}
}
public DataFileService(IDatabase db, ModelRepository repo, ILogger logger, DispatchService dispatch)
{
_db = db;
_repo = repo;
_logger = logger;
_dispatch = dispatch;
}
public void PlaylistsPanelLoad_ShouldCreateOneAssociationControlPerAvailablePlaylist()
{
List<Playlist> playlists = BuildListOfDummyPlaylists(2);
ModelRepository model = new ModelRepository();
model.Add("devices", new DeviceCollection());
MockMediaSoftwareService mockMediaSoftwareService = new MockMediaSoftwareService();
mockMediaSoftwareService.SetPlaylists(playlists);
PlaylistsPanel playlistsPanel = new PlaylistsPanel();
playlistsPanel.MediaSoftwareService = mockMediaSoftwareService;
playlistsPanel.Model = model;
playlistsPanel.PlaylistsPanel_Load(this, null);
int numberOfAssociationControlsCreated = 0;
foreach (Control panelControl in playlistsPanel.FlowPlaylistAssociations.Controls)
{
Console.WriteLine(String.Format("Control type: {0}", panelControl.GetType().ToString()));
if (panelControl is PlaylistAssociationControl)
{
numberOfAssociationControlsCreated++;
}
}
Assert.AreEqual(playlists.Count(), numberOfAssociationControlsCreated);
}
public void ModelRepositoryGetAllTest()
{
//Arrange
IncludeAllMappings.include();
var vModel = new VehicleModelDomain()
{
Name = "ModelRepositoryUpdateTest", Abrv = "ModelRepositoryUpdateTest", VehicleModelId = Guid.NewGuid(), VehicleMakeId = Guid.Parse("03f3a155-c7a2-e611-9c16-b88687075332")
};
var context = new VehicleContext();
var repository = new Repositorys.Repository(context, new UnitOfWorkFactory(new UnitOfWork(context)));
var testRepository = new ModelRepository(repository);
Task.Run(async() =>
{
var response = await testRepository.Add(vModel);
Assert.AreEqual(1, response);
}).GetAwaiter().GetResult();
//Act
Task.Run(async() =>
{
var result = await testRepository.Add(vModel);
//Assert
Assert.IsNotNull(result);
}).GetAwaiter().GetResult();
}
public CommandMessageService(IDatabase db, ModelRepository repo, IClock clock, ILogger logger)
{
_db = db;
_repo = repo;
_clock = clock;
_logger = logger.ForContext <CommandMessageService>();
}
public async void GetExportModels_FromDatabaseWithTwoModels()
{
// Arrange
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
await using var context = new ApplicationDbContext(options);
var allModels = GenerateModels();
await context.Models.AddRangeAsync(allModels);
var numAdded = await context.SaveChangesAsync();
var repo = new ModelRepository <ApplicationDbContext>(context);
var sut = new ModelService(repo, AuditMock.Object, _mapper);
// Act
var query = new ModelExportQuery
{
Search = "vendor"
};
var models = await sut.GetModelExportAsync(query);
var result = _mapper.Map <List <ExportModelDto> >(models);
// Assert
Assert.Equal("storage0", result[0].cpu);
Assert.Equal(4, result.Count);
}
public async Task ShoudGetProjects()
{
var modelRepository = new ModelRepository();
var actual = await modelRepository.GetModels(_projectId);
Assert.NotNull(actual.First().Id);
}
public void AllModelsShouldBeAvalable()
{
ModelRepository repository = new ModelRepository();
var models = repository.LoadAll();
Assert.That(models.Count, Is.EqualTo(4));
}
protected override XmlSerializationContext CreateSerializationContext(object root)
{
var tempRepository = new ModelRepository();
tempRepository.Locators.Add(FileLocator.Instance);
tempRepository.Serializer = this;
return new ModelSerializationContext(tempRepository, CreateModelForRoot(root));
}
public async Task <ActionResult> RegisterUser(User user)
{
if (!ModelState.IsValid)
{
return(GetValidationMessages().ToJsonResult());
}
var existsUserName = await ModelRepository
.SingleAsync(existingUser => string.Equals(existingUser.UserName, user.UserName, StringComparison.InvariantCultureIgnoreCase)).ConfigureAwait(false);
if (existsUserName != null)
{
return(string.Format("El usuario '{0}' ya existe en el sistema", user.UserName).ToJsonResult());
}
user.RoleId = Settings.DefaultUserRoleDbId;
user.IsAuthorized = false;
var userToSave = Mapper.Map <DataAccess.Entities.User>(user);
userToSave = await ModelRepository.AddAsync(userToSave).ConfigureAwait(false);
var savedUser = Mapper.Map <User>(userToSave);
var recipients = (await ModelRepository
.GetAllAsync(admin => admin.RoleId == Settings.AdministratorUserRoleDbId))
.Select(admin => admin.Email);
var htmlBody = user.GetHtmlFromXslt(Server.MapPath(Settings.NewUserTemplateFilePath), XsltParameters);
await _emailSender.Send(Settings.SmtpEmail, recipients, Settings.NewUserAuthorizationSubject, htmlBody);
return(savedUser.ToJsonResult());
}
public MessageDeleted(ILogger logger, IDatabase db, ModelRepository repo, LastMessageCacheService lastMessage)
{
_db = db;
_repo = repo;
_lastMessage = lastMessage;
_logger = logger.ForContext <MessageDeleted>();
}
public void MakeServiceReadTest()
{
//Arange
IncludeAllMappings.include();
var context = new VehicleContext();
var repository = new Repository.Repositorys.Repository(context, new UnitOfWorkFactory(new UnitOfWork(context)));
var makeRepository = new MakeRepository(repository);
var modelRepository = new ModelRepository(repository);
var vMake = new VehicleMakeDomain()
{
Name = "MakeServiceReadTest", Abrv = "MakeServiceReadTest", VehicleModel = null
};
var testService = new MakeService(makeRepository, modelRepository);
IEnumerable <IVehicleMakeDomain> readAll = null;
IVehicleMakeDomain targetItem = null;
Task.Run(async() =>
{
readAll = await testService.ReadAll();
Assert.IsNotNull(readAll);
targetItem = readAll.LastOrDefault();
}).GetAwaiter().GetResult();
Task.Run(async() =>
{
//Act
var result = await testService.Read(targetItem.VehicleMakeId);
//Assert
Assert.AreEqual(targetItem.VehicleMakeId, result.VehicleMakeId);
}).GetAwaiter().GetResult();
}
static void Initialize()
{
stopwatch.Restart();
repository = new ModelRepository();
ChangePath = Environment.GetEnvironmentVariable(nameof(ChangePath));
RunIndex = Environment.GetEnvironmentVariable(nameof(RunIndex));
Sequences = int.Parse(Environment.GetEnvironmentVariable(nameof(Sequences)));
Tool = Environment.GetEnvironmentVariable(nameof(Tool));
ChangeSet = Environment.GetEnvironmentVariable(nameof(Tool));
Query = Environment.GetEnvironmentVariable(nameof(Query)).ToUpperInvariant();
if (Query == "Q1")
{
solution = new BatchSolutionQ1();
}
else if (Query == "Q2")
{
solution = new BatchSolutionQ2();
}
else
{
throw new ApplicationException("Query is unknown");
}
stopwatch.Stop();
Report(BenchmarkPhase.Initialization);
}
public Model GetByUrl(string url, string manufacturerUrl)
{
List<QueryParameter> parameters = new List<QueryParameter>();
parameters.Add(new QueryParameter("url", url));
parameters.Add(new QueryParameter("manufacturerUrl", manufacturerUrl));
List<Model> models = new ModelRepository().GetByParameter("getByUrl", parameters, false);
return models.Count > 0 ? models[0] : null;
}
/*!
* Populates the ModelRepository with configuration from file.
*/
public static ModelRepository LoadModelRepository(ConfigurationChecker configurationChecker)
{
ModelRepository repo = new ModelRepository();
LoadApplicationConfiguration(configurationChecker, repo);
LoadStoredDevices(repo);
return repo;
}
public static void TestCanCount()
{
var repository = new ModelRepository ();
repository.DeleteAll ();
repository.Insert (getModels ());
var count = repository.CountAll ();
Assert.True (count == getModels ().Count (), "Incorrect count");
}
public void SetUp()
{
model = new ModelRepository();
devices = new DeviceCollection();
device = new Device();
device.Name = "Test device";
device.Identifier = "test";
devices.Devices.Add(device);
model["devices"] = devices;
}
public static void TestCanDeleteAll()
{
var repository = new ModelRepository ();
repository.Insert (getModels ());
var preCount = repository.CountAll ();
repository.DeleteAll ();
var postCount = repository.CountAll ();
Assert.True (preCount > 0, "No records were available to delete");
Assert.True (postCount == 0, "Failed to delete all records");
}
public ActionResult Create(EmployeeViewModel viewModel)
{
if (!ModelState.IsValid)
{
return View(viewModel);
}
using (ModelRepository db = new ModelRepository(this._factory.GetDatabaseObject()))
{
EmployeeService service = new EmployeeService(db);
service.Add(this._toBusinessModel(viewModel));
db.SaveChanges();
}
return RedirectToAction("Index");
}
public static void TestCanDelete()
{
var repository = new ModelRepository ();
repository.Insert (getModels ());
var models = repository.GetAll ();
var list = new List<long> () { models.First ().Id };
repository.Delete (list);
var postCount = repository.CountAll ();
var reRead = repository.Get (list);
Assert.True (postCount == models.Count () - 1, "Post delete count is incorrect");
Assert.True (reRead.Count () == 0, "Could retrieve the model after deletion");
}
//
// GET: /Department/Delete
public ActionResult Delete(long? id)
{
if (id == null)
{
return RedirectToAction("Index");
}
var viewModel = new DepartmentViewModel();
using (ModelRepository db = new ModelRepository(this._factory.GetDatabaseObject()))
{
DepartmentService service = new DepartmentService(db);
var model = service.GetObject(x => x.id == id);
if (model == null)
{
return RedirectToAction("Index");
}
viewModel = this._toViewModel(model);
}
return View(viewModel);
}
private void LoadConfiguration()
{
modelRepository = ApplicationUtils.LoadModelRepository(configurationChecker);
}
public static void TestCanInsert()
{
var repository = new ModelRepository ();
var preModels = getModels ();
repository.Insert (preModels);
var postModels = repository.GetAll ();
var orderdPreModels = preModels.OrderBy (m => m.Name).ThenBy (m => m.DateOfBirth).ThenBy (m => m.Height);
var orderedPostModels = postModels.OrderBy (m => m.Name).ThenBy (m => m.DateOfBirth).ThenBy (m => m.Height);
Assert.IsTrue (orderdPreModels.Count () == orderedPostModels.Count ());
// TODO: better equality comparison
Assert.IsTrue (orderdPreModels.ElementAt (0).Name.Equals (orderedPostModels.ElementAt (0).Name));
}
//
// GET: /SampleData/
public ActionResult Index(int? page = 1)
{
IPagedList<SampleDataViewModel> pagedList = null;
using (ModelRepository db = new ModelRepository(this._factory.GetDatabaseObject()))
{
SampleDataService service = new SampleDataService(db);
pagedList = service.GetPagedList(this._toViewModel, page ?? 1);
}
return View(pagedList);
}
//
// GET: /Department/
public ActionResult Index()
{
var modelList = new List<DepartmentViewModel>();
using (ModelRepository db = new ModelRepository(this._factory.GetDatabaseObject()))
{
DepartmentService service = new DepartmentService(db);
foreach (var model in service.GetObjectList())
{
modelList.Add(this._toViewModel(model));
}
}
return View(modelList);
}
//
// GET: /Employee/
//[OutputCache(CacheProfile = "Long", VaryByHeader = "X-Requested-With;Accept-Language", Location = OutputCacheLocation.Server)]
public ActionResult Index(int? page = 1)
{
IPagedList<EmployeeViewModel> list = null;
using (ModelRepository db = new ModelRepository(this._factory.GetDatabaseObject()))
{
EmployeeService service = new EmployeeService(db);
list = service.GetPagedList(this._toViewModel, page ?? 1);
}
return View(list);
}
public ActionResult Edit(DepartmentViewModel viewModel)
{
if (!ModelState.IsValid)
{
return View(viewModel);
}
using (ModelRepository db = new ModelRepository(this._factory.GetDatabaseObject()))
{
DepartmentService service = new DepartmentService(db);
var model = service.GetObject(x => x.id == viewModel.Id);
if (model == null)
{
return RedirectToAction("Index");
}
service.Update(this._toBusinessModel(viewModel));
db.SaveChanges();
}
return RedirectToAction("Index");
}
public ActionResult Edit(SampleDataViewModel viewModel)
{
if (!ModelState.IsValid)
{
return View(viewModel);
}
using (ModelRepository db = new ModelRepository(this._factory.GetDatabaseObject()))
{
SampleDataService service = new SampleDataService(db);
var model = service.GetObjectList(x => x.Id == viewModel.Id).FirstOrDefault();
if (model == null)
{
return RedirectToAction("Index");
}
service.Update(this._toBusinessModel(viewModel));
db.SaveChanges();
}
return RedirectToAction("Index");
}
//
// GET: /SampleData/Edit
public ActionResult Edit(long? id)
{
if (id == null)
{
return RedirectToAction("Index");
}
var viewModel = new SampleDataViewModel();
using (ModelRepository db = new ModelRepository(this._factory.GetDatabaseObject()))
{
SampleDataService service = new SampleDataService(db);
var model = service.GetObjectList(x => x.Id == id).FirstOrDefault();
if (model == null)
{
return RedirectToAction("Index");
}
viewModel = this._toViewModel(model);
}
return View(viewModel);
}
//
// GET: /Department/
public ActionResult Index(int? page = 1)
{
IPagedList<DepartmentViewModel> modelList = null;
using (ModelRepository db = new ModelRepository(this._factory.GetDatabaseObject()))
{
DepartmentService service = new DepartmentService(db);
modelList = service.GetPagedList(this._toViewModel, page ?? 1);
}
return View(modelList);
}
public static void TestCanUpdate()
{
var repository = new ModelRepository ();
repository.Insert (getModels ());
var model = repository.GetAll ().First ();
model.Name = "Updated Model";
repository.Update (model);
var updateModel = repository.Get (new List<long> (){model.Id}).First ();
Assert.IsTrue (model.Name == updateModel.Name, "Bugger");
}
public int Save(BE.Model model)
{
ModelRepository repository = new ModelRepository();
if(model.ID > 0)
return repository.Update(model);
else
return repository.Insert(model);
}
