public IActionResult Create(History history)
        {
            history.Id = 0;
            _repository.Create(history);
            Pet addPetHistory = _petRepository.GetPetById(history.PetId);

            addPetHistory.Histories.Add(history);
            return(RedirectToAction("Detail", "Pet", _petRepository.GetPetById(history.PetId)));
        }
        public void CreateHistory(SiteBL site)
        {
            var history = new HistoryBL
            {
                Date            = DateTime.Now,
                MaxResponseTime = site.MaxResponseTime,
                MinResponseTime = site.MinResponseTime,
                SiteId          = site.Id,
                SiteURL         = site.Url
            };

            var historyToCreate = _mapper.Map <History>(history);

            _historyRepository.Create(historyToCreate);
        }
        public async Task <HistoryViewDTO> Create(History history)
        {
            var validationResult = _historyValidator.Validate(history);

            if (!validationResult.IsValid)
            {
                throw new Exception(validationResult.ToString());
            }
            else
            {
                var createResult = await _historyRepository.Create(history);

                var mapperResult = _mapper.Map <History, HistoryViewDTO>(createResult);
                return(mapperResult);
            }
        }
Esempio n. 4
0
        public History Pay(string id)
        {
            ExternalCart cartToPay = Get(id);

            if (cartToPay.Products.Count == 0)
            {
                return(null);
            }
            History history = new History(cartToPay);

            foreach (var product in cartToPay.Products)
            {
                RemoveProduct(id, product.Id);
            }

            return(_historyRepository.Create(history));
        }
Esempio n. 5
0
        public void CreateResponseHistory(string timageId, TinyResponse responseItem)
        {
            var newItem = new TinyPNGResponseHistory
            {
                OccuredAt     = DateTime.UtcNow,
                IsOptimized   = responseItem.Output.IsOptimized,
                ImageId       = timageId,
                Error         = responseItem.Output.Error,
                Ratio         = responseItem.Output.Ratio,
                OptimizedSize = responseItem.Output.Size
            };

            if (responseItem.Input != null)
            {
                newItem.OriginSize = responseItem.Input.Size;
                newItem.Error      = string.Empty;
            }

            _historyRepository.Create(newItem);
        }
Esempio n. 6
0
        public IActionResult CreateHistory([FromBody] HistoryCreateRequest req)
        {
            HistoryResponse resp = _historyRepository.Create(req);

            return(CreatedAtAction("GetHistoryById", new { historyId = resp.Id }, resp));
        }
Esempio n. 7
0
        public virtual void ApplyMigrations(string targetMigration = null)
        {
            var connection = _connection.DbConnection;

            _logger.Value.LogVerbose(Strings.UsingConnection(connection.Database, connection.DataSource));

            var migrations = _migrationAssembly.Migrations;
            var appliedMigrationEntries = _historyRepository.GetAppliedMigrations();

            var appliedMigrations   = new List <Migration>();
            var unappliedMigrations = new List <Migration>();

            foreach (var migraion in migrations)
            {
                if (appliedMigrationEntries.Any(
                        e => string.Equals(e.MigrationId, migraion.Id, StringComparison.OrdinalIgnoreCase)))
                {
                    appliedMigrations.Add(migraion);
                }
                else
                {
                    unappliedMigrations.Add(migraion);
                }
            }

            IEnumerable <Migration> migrationsToApply;
            IEnumerable <Migration> migrationsToRevert;

            if (string.IsNullOrEmpty(targetMigration))
            {
                migrationsToApply  = unappliedMigrations;
                migrationsToRevert = Enumerable.Empty <Migration>();
            }
            else if (targetMigration == InitialDatabase)
            {
                migrationsToApply  = Enumerable.Empty <Migration>();
                migrationsToRevert = appliedMigrations;
            }
            else
            {
                targetMigration   = _idGenerator.ResolveId(targetMigration, migrations);
                migrationsToApply = unappliedMigrations
                                    .Where(m => string.Compare(m.Id, targetMigration, StringComparison.OrdinalIgnoreCase) <= 0);
                migrationsToRevert = appliedMigrations
                                     .Where(m => string.Compare(m.Id, targetMigration, StringComparison.OrdinalIgnoreCase) > 0)
                                     .OrderByDescending(m => m.Id);
            }

            bool first;
            var  checkFirst = true;

            foreach (var migration in migrationsToApply)
            {
                var batches = ApplyMigration(migration).ToList();

                first = false;
                if (checkFirst)
                {
                    first = migration == migrations[0];
                    if (first && !_historyRepository.Exists())
                    {
                        // TODO: Consider removing check above and always using "if not exists"
                        batches.Insert(0, new SqlBatch(_historyRepository.Create(ifNotExists: false)));
                    }

                    checkFirst = false;
                }

                _logger.Value.LogInformation(Strings.ApplyingMigration(migration.Id));

                Execute(batches, first);
            }

            foreach (var migration in migrationsToRevert)
            {
                _logger.Value.LogInformation(Strings.RevertingMigration(migration.Id));

                Execute(RevertMigration(migration));
            }
        }