private static async Task Sample2(IEventStore store) { using (var scope = new TransactionScope(TransactionScopeOption.RequiresNew, options, TransactionScopeAsyncFlowOption.Enabled)) { var repo = new Repository <ShoppingCart>(store); var streamId = SequentialGuid.NewGuid(); var aggregate = new ShoppingCart(streamId, SequentialGuid.NewGuid()); aggregate.AddItem(SequentialGuid.NewGuid(), name: "Product 1", quantity: 3); var item2Id = SequentialGuid.NewGuid(); aggregate.AddItem(item2Id, name: "Product 2", quantity: 1); aggregate.AddItem(SequentialGuid.NewGuid(), name: "Product 3", quantity: 5); aggregate.RemoveItem(item2Id); aggregate.AddItem(SequentialGuid.NewGuid(), name: "Product 4", quantity: 1); var snap = aggregate.GetSnapshot(); await repo.SaveChangesAsync(aggregate); await store.Advanced.UpdateSnapshotAsync(aggregate.Id, snap.Version, snap.State); aggregate = await repo.LoadAsync(streamId); aggregate.AddItem(SequentialGuid.NewGuid(), name: "Product 5", quantity: 5); await repo.SaveChangesAsync(aggregate); aggregate = await repo.LoadAsync(streamId); Console.WriteLine($@"Aggregate expected version 7 = {aggregate.CommittedVersion}"); scope.Complete(); } }
public async Task AddAsync(GrupoIndexDTO grupoDTO) { Grupo grupo = grupoDTO.BuildModel(); await _repository.AddAsync(grupo); await _repository.SaveChangesAsync(); }
public virtual async Task <IActionResult> Put(int id, T item) { if (id != item.Id) { return(BadRequest()); } await repo.UpdateAsync(item); try { await repo.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!repo.FindBy(a => a.Id == id).Any()) { return(NotFound()); } else { throw; } } return(NoContent()); }
private async Task SeedCustomCakeImg(CakeItDbContext db) { var repo = new Repository <CustomCakeImg>(db); var mock = new Mock <ILogger <CustomCakeService> >(); ILogger <CustomCakeService> logger = mock.Object; var service = new CustomCakeService(null, repo, this.Mapper, logger); CustomCakeImgViewModel model1 = new CustomCakeImgViewModel { Side = "White Cigarettes", Top = "Habana", Name = "Habana" + " " + "White Cigarettes", Img = "https://someurl.bg" }; await service.AddCustomCakeImg(model1); CustomCakeImgViewModel model2 = new CustomCakeImgViewModel { Side = "Dark Cigarettes", Top = "Meksiko", Name = "Meksiko" + " " + "Dark Cigarettes", Img = "https://otherurl.bg" }; await service.AddCustomCakeImg(model2); await repo.SaveChangesAsync(); }
/// <summary> /// Implementation of <see cref="ICategoryCommands.UpdateCategoryInfo(Guid, string, string, string, string, bool, DateTime?, DateTime?)"/> /// </summary> /// <param name="categoryId">The category id</param> /// <param name="code">The category code</param> /// <param name="name">The category name</param> /// <param name="url">The category url</param> /// <param name="description">The category description</param> /// <param name="isVisible">Whether the category is visible</param> /// <param name="visibleFrom">The date and time from when the category is visible</param> /// <param name="visibleTo">The date and time till when the category is visible</param> /// <returns></returns> public virtual async Task UpdateCategoryInfo(Guid categoryId, string code, string name, string url, string description, bool isVisible, DateTime?visibleFrom, DateTime?visibleTo) { try { if (categoryId == Guid.Empty) { throw new ArgumentException("value cannot be empty", nameof(categoryId)); } var category = await Repository.GetByKeyAsync <Category>(categoryId); if (category.Code != code) { category.ChangeCode(code); } if (category.Name != name) { category.ChangeName(name); } if (category.Url != url) { category.ChangeUrl(url); } if (category.Description != description) { category.ChangeDescription(description); } if (category.IsVisible != isVisible) { if (isVisible) { if (!visibleFrom.HasValue && !visibleTo.HasValue) { category.SetAsVisible(); } else { category.SetAsVisible(visibleFrom, visibleTo); } } else { category.Hide(); } } await Repository.SaveChangesAsync(); var @event = new CategoryInfoUpdatedEvent(categoryId, code, name, url, description, isVisible, visibleFrom, visibleTo); EventBus.RaiseEvent(@event); } catch { throw; } }
/// <summary> /// Implementation of <see cref="ICategoryCommands.CreateNewCategory(string, string, string, string, bool, DateTime?, DateTime?)"/> /// </summary> /// <param name="code">The category code</param> /// <param name="name">The category name</param> /// <param name="url">The category url</param> /// <param name="description">The category description</param> /// <param name="isVisible">Whether the category is visible</param> /// <param name="visibleFrom">The date and time of when the category starts to be visible</param> /// <param name="visibleTo">The date and time till when the category is visible</param> /// <returns>The category id</returns> public virtual async Task <Guid> CreateNewCategory(string code, string name, string url, string description, bool isVisible, DateTime?visibleFrom, DateTime?visibleTo) { try { var category = Category.Create(code, name, url); if (!string.IsNullOrEmpty(description)) { category.ChangeDescription(description); } if (isVisible) { if (!visibleFrom.HasValue && !visibleTo.HasValue) { category.SetAsVisible(); } else { category.SetAsVisible(visibleFrom, visibleTo); } } Repository.Add(category); await Repository.SaveChangesAsync(); var @event = new CategoryCreatedEvent(category.Id, name, code); EventBus.RaiseEvent(@event); return(category.Id); } catch { throw; } }
/// <summary> /// Implementation of <see cref="ICategoryCommands.RemoveParentForCategory(Guid, Guid)"/> /// </summary> /// <param name="categoryId">The category id</param> /// <param name="parentId">The category parent id</param> /// <returns></returns> public virtual async Task RemoveParentForCategory(Guid categoryId, Guid parentId) { try { if (categoryId == Guid.Empty) { throw new ArgumentException("value cannot be empty", nameof(categoryId)); } var category = await Repository.GetByKeyAsync <Category>(categoryId); if (parentId != Guid.Empty) { var parent = await Repository.GetByKeyAsync <Category>(parentId); category.RemoveParent(parent); await Repository.SaveChangesAsync(); var @event = new CategoryChildRemovedEvent(parentId, categoryId); EventBus.RaiseEvent(@event); } } catch { throw; } }
/// <summary> /// Implementation of <see cref="ICategoryCommands.AddCategoryChild(Guid, Guid)"/> /// </summary> /// <param name="categoryId">The category id</param> /// <param name="childId">The child id</param> /// <returns></returns> public virtual async Task AddCategoryChild(Guid categoryId, Guid childId) { try { if (categoryId == Guid.Empty) { throw new ArgumentException("value cannot be empty", nameof(categoryId)); } if (childId == Guid.Empty) { throw new ArgumentException("value cannot be empty", nameof(childId)); } var category = await Repository.GetByKeyAsync <Category>(categoryId); var child = await Repository.GetByKeyAsync <Category>(childId); category.AddChild(child); await Repository.SaveChangesAsync(); var @event = new CategoryChildAddedEvent(categoryId, childId); EventBus.RaiseEvent(@event); } catch { throw; } }
private async Task <int> Vote(int itemId, bool upvote) { var value = upvote ? 1 : -1; var user = await GetRequestUser(); var solution = await Get(itemId); var castVote = await Repository.Votes.GetVoteByItemIdAndUser(itemId, user.UserId); var vote = new Sql.Models.Vote(); vote.ItemId = itemId; vote.Value = value; if (castVote == null) { vote.Voter = user; await Repository.Votes.Create(vote); await Repository.SaveChangesAsync(); } else if (castVote.Value != vote.Value) { castVote.Value = vote.Value; await Repository.SaveChangesAsync(); } return(await Repository.Votes.GetCountForItemId(solution.SolutionId)); }
public async Task <string> EditAsync(int id, Sql.Models.Problem problem) { if (problem == null) { throw new ArgumentNullException(nameof(problem)); } if (string.IsNullOrEmpty(problem.Description) || string.IsNullOrWhiteSpace(problem.Name) || !problem.TestCases.Any()) { throw new Exception("All details are required to create a problem"); } var user = await GetRequestUser(); var existingProblem = await Repository.Problem.Get(id); if (existingProblem == null) { throw new ArgumentNullException(nameof(problem)); } if (user.UserId != existingProblem.Author.UserId) { throw new Exception("User is not author!"); } existingProblem.TestCases = problem.TestCases; existingProblem.Description = problem.Description; existingProblem.Language = problem.Language; existingProblem.Name = problem.Name; await Repository.SaveChangesAsync(); return(Url.Action("Index", new { problem.ProblemId })); }
public override async Task HandleAsync(ImportBaylorRegistrationsCommand command) { var sr = new StringReader(command.ViewModel.Data); var csv = new CsvReader(sr); csv.Configuration.MissingFieldFound = null; if (command.ViewModel.TabDelimeter) { csv.Configuration.Delimiter = "\t"; } csv.Read(); csv.ReadHeader(); while (csv.Read()) { var email = csv.GetField("Username"); var user = await _userManager.FindByEmailAsync(email); if (user == null) { continue; } var completed = csv.GetField("Registration complete"); //yes or no user.IsBaylorRegistrationCompleted = (completed == "yes"); } await Repository.SaveChangesAsync(); }
/// <summary> /// Implementation of <see cref="IBrandCommands.CreateNewBrand(string, string, string, Image)"/> /// </summary> /// <param name="name">The brand's name</param> /// <param name="url">The brand's unique url</param> /// <param name="description">The brand's description</param> /// <param name="logo">The brand's logo</param> /// <returns>The brand id</returns> public virtual async Task <Guid> CreateNewBrand(string name, string url, string description, Image logo) { try { var brand = Brand.Create(name, url); if (!string.IsNullOrEmpty(description)) { brand.ChangeDescription(description); } if (logo != null) { brand.SetLogo(logo); } Repository.Add(brand); await Repository.SaveChangesAsync(); var @event = new BrandCreatedEvent(brand.Id, brand.Name); EventBus.RaiseEvent(@event); return(brand.Id); } catch { throw; } }
public async Task CreateAsync(CreateBrandBindingModel model) { Brand brand = this.Mapper.Map <Brand>(model); await Repository.AddAsync(brand); await Repository.SaveChangesAsync(); }
public async Task Should_Delete_Entities_Async() { var options = DatabaseOptionsWithData <FakeDbContext>(typeof(FakeDbContext)); var fakeEntities = new FakeEntities(); var fakeEntity = fakeEntities[0]; using (IDbContext context = new FakeDbContext(options)) { var repository = new Repository <FakeEntity>(context); var entitiesToDelete = await repository.SelectAsync(); await repository.DeleteAsync(entitiesToDelete); var saveCount = await repository.SaveChangesAsync(); Assert.Equal(entitiesToDelete.Count(), saveCount); } using (IDbContext context = new FakeDbContext(options)) { var repository = new Repository <FakeEntity>(context); var result = await repository.SelectAsync(); var singleResult = result.Single(prop => prop.EntityCode == fakeEntity.EntityCode); Assert.Equal(fakeEntities.Count, result.Count()); Assert.All(result, prop => Assert.True(prop.IsDeleted)); Assert.All(result, prop => Assert.True(prop.DeletedTime == prop.ModifiedTime)); Assert.All(result, prop => Assert.True(prop.ModifiedTime > prop.CreatedTime)); Assert.All(result, prop => Assert.Equal(Principal.Identity.Name, prop.ModifiedBy)); } }
public async Task Should_Update_Entities_Async() { var options = DatabaseOptionsWithData <FakeDbContext>(typeof(FakeDbContext)); var fakeEntities = new FakeEntities(); using (IDbContext context = new FakeDbContext(options)) { var repository = new Repository <FakeEntity>(context); var entitiesToUpdate = (await repository.SelectAsync()).ToList(); entitiesToUpdate.ForEach(entity => entity.EntityName = "Modified"); var result = await repository.UpdateAsync(entitiesToUpdate); var saveCount = await repository.SaveChangesAsync(); Assert.All(entitiesToUpdate, prop => Assert.True(prop.Id > 0)); Assert.Equal(entitiesToUpdate.Count, saveCount); } using (IDbContext context = new FakeDbContext(options)) { var repository = new Repository <FakeEntity>(context); var result = await repository.SelectAsync(); Assert.Equal(fakeEntities.Count, result.Count()); Assert.All(result, prop => Assert.Equal("Modified", prop.EntityName)); Assert.All(result, prop => Assert.Equal(Principal.Identity.Name, prop.ModifiedBy)); Assert.All(result, prop => Assert.True(prop.ModifiedTime > prop.CreatedTime)); } }
public async Task Should_Insert_Entities_Async() { var options = DatabaseOptions <FakeDbContext>(); var fakeEntities = new FakeEntities(); fakeEntities.ForEach(entity => entity.FakeChildEntities = null); using (IDbContext context = new FakeDbContext(options)) { var repository = new Repository <FakeEntity>(context); var result = await repository.InsertAsync(fakeEntities); var saveCount = await repository.SaveChangesAsync(); Assert.True(result.Count() > 0); Assert.All(result, prop => Assert.True(prop.Id > 0)); Assert.Equal(fakeEntities.Count, saveCount); } using (IDbContext context = new FakeDbContext(options)) { var repository = new Repository <FakeEntity>(context); var result = await repository.SelectAsync(); var entryDateTime = result.First().CreatedTime; Assert.Equal(fakeEntities.Count, result.Count()); Assert.All(result, prop => Assert.True(prop.Id > 0)); Assert.All(result, prop => Assert.Equal(Principal.Identity.Name, prop.CreatedBy)); Assert.All(result, prop => Assert.Equal(entryDateTime, prop.CreatedTime, TimeSpan.FromMinutes(1))); } }
public async Task Should_Insert_Entity_Async() { var options = DatabaseOptions <FakeDbContext>(); var fakeEntity = new FakeEntities()[0]; fakeEntity.FakeChildEntities = null; using (IDbContext context = new FakeDbContext(options)) { var repository = new Repository <FakeEntity>(context); var result = await repository.InsertAsync(fakeEntity); var saveCount = await repository.SaveChangesAsync(); Assert.True(result.Id > 0); Assert.Equal(1, saveCount); } using (IDbContext context = new FakeDbContext(options)) { var repository = new Repository <FakeEntity>(context); var result = await repository.SelectAsync(prop => prop.EntityCode == fakeEntity.EntityCode); Assert.Single(result); Assert.True(result.First().Id > 0); Assert.True(result.First().EntityCode == fakeEntity.EntityCode); Assert.True(result.First().EntityName == fakeEntity.EntityName); Assert.Equal(Principal.Identity.Name, result.First().CreatedBy); Assert.True(result.First().CreatedTime > DateTime.MinValue); } }
public async Task <ActionResult> PutAsync(int id, [FromBody] Event evt) { Event evtDB; try { evtDB = await Repository.GetByIdAsync(id); } catch (Exception ex) { // internal server error return(StatusCode(500, ex)); } if (evtDB == null) { return(NotFound()); // if resource doesn't exist, i'll return an error } if (id != evtDB.Id) { return(BadRequest("cannot change ID")); } try { await Repository.UpdateAsync(evt, id); await Repository.SaveChangesAsync(); } catch (Exception ex) { // internal server error return(StatusCode(500, ex)); } // return proper 204 No Content response return(NoContent()); // success = Ok() }
public override async Task HandleAsync(TCommand command) { var dbRegistration = await Repository.Set <TeamContestRegistration>() .SingleOrDefaultAsync(r => r.Id == command.RegistrationId); if (dbRegistration == null) { throw new EntityNotFoundException(); } var validationResult = await ValidateEditTeamContestRegistrationAsync(command.ViewModel); if (validationResult.Any()) { throw new ValidationException(validationResult); } _mapper.Map(command.ViewModel, dbRegistration); if (dbRegistration.Status == ContestRegistrationStatus.Completed && dbRegistration.RegistrationDateTime == null) { dbRegistration.RegistrationDateTime = DateTimeService.SfuServerNow; dbRegistration.RegistredBy = await _userManager.FindByEmailAsync(_currentUserService.Email); } await Repository.SaveChangesAsync(); }
public async Task <ActionResult> DeleteAsync(int id) { Event evtDB; try { evtDB = await Repository.GetByIdAsync(id); if (evtDB == null) { return(NotFound()); // if resource doesn't exist, i'll return an error } evtDB = null; await Repository.DeleteAsync(id); await Repository.SaveChangesAsync(); } catch (Exception ex) { // internal server error return(StatusCode(500, ex)); } // return proper 204 No Content response return(NoContent()); // success = Ok() }
/// <summary> /// Implementation of <see cref="ICustomerCommands.RestoreCustomer(Guid)"/> /// </summary> /// <param name="customerId">The customer id</param> /// <returns></returns> public async Task RestoreCustomer(Guid customerId) { if (customerId == Guid.Empty) { throw new ArgumentException("value cannot be empty", nameof(customerId)); } var customer = await Repository.GetByKeyAsync <Customer>(customerId); if (customer == null) { throw new ArgumentOutOfRangeException(nameof(customerId)); } try { customer.Restore(); if (customer.HasAccount && customer.Account.IsLocked) { await AuthClient.EnableAccount(customer.Account.UserId); customer.UnlockAccount(); } await Repository.SaveChangesAsync(); var @event = new CustomerRestoredEvent(customerId); EventBus.RaiseEvent(@event); } catch { throw; } }
public override async Task <FeedViewModel> AddAsync <TCreateRequest>(TCreateRequest createRequest) { if (!(createRequest is CreateFeedRequest request)) { var message = GetImproperRequestErrorMessage(typeof(TCreateRequest), nameof(IFeedService)); throw new ArgumentException(message); } var entity = createRequest.CreateEntity(); var createdEntity = await Repository.AddAsync(entity); await Repository.SaveChangesAsync(); var tempEntity = await Repository.GetFeedWithAfflictionsById(createdEntity.Id); createdEntity.DogAfflictions = tempEntity.DogAfflictions; var viewModel = new FeedViewModel(); viewModel.Construct(createdEntity); await _imageService.AddImagesAsync(request.Photos, viewModel.UniqueId); viewModel.PhotosIds = await _imageService.GetImagesIdsByOwnerGuidAsync( viewModel.UniqueId, CancellationToken.None); return(viewModel); }
/// <summary> /// Implementation of <see cref="ICustomerCommands.RemoveCustomerBillingInformation(Guid, Guid)"/> /// </summary> /// <param name="customerId">The customer id</param> /// <param name="billingInfoId">The billing info id</param> /// <returns></returns> public async Task RemoveCustomerBillingInformation(Guid customerId, Guid billingInfoId) { if (customerId == Guid.Empty) { throw new ArgumentException("value cannot be empty", nameof(customerId)); } if (billingInfoId == Guid.Empty) { throw new ArgumentException("value cannot be empty", nameof(billingInfoId)); } var customer = await Repository.GetByKeyAsync <Customer>(customerId); if (customer == null) { throw new ArgumentOutOfRangeException(nameof(customerId)); } customer.RemoveBillingInfo(billingInfoId); await Repository.SaveChangesAsync(); var @event = new BillingoInformationRemovedEvent(customerId, billingInfoId); EventBus.RaiseEvent(@event); }
/// <summary> /// Implementation of <see cref="ICustomerCommands.RemoveCustomerShippingAddress(Guid, Guid)"/> /// </summary> /// <param name="customerId">The customer id</param> /// <param name="addressId">The address id</param> /// <returns></returns> public async Task RemoveCustomerShippingAddress(Guid customerId, Guid addressId) { if (customerId == Guid.Empty) { throw new ArgumentException("value cannot be empty", nameof(customerId)); } if (addressId == Guid.Empty) { throw new ArgumentException("value cannot be empty", nameof(addressId)); } var customer = await Repository.GetByKeyAsync <Customer>(customerId); if (customer == null) { throw new ArgumentOutOfRangeException(nameof(customerId)); } customer.RemoveShippingAddress(addressId); await Repository.SaveChangesAsync(); var @event = new ShippingAddressRemovedEvent(customerId, addressId); EventBus.RaiseEvent(@event); }
/// <summary> /// Implementation of <see cref="ICustomerCommands.RegisterNewPerson(string, string, string, Gender, DateTime)"/> /// </summary> /// <param name="firstName">The first name</param> /// <param name="lastName">The last name</param> /// <param name="nationalIdentificationNumber">The national identification number</param> /// <param name="gender">The gender</param> /// <param name="birthDate">The birth date</param> /// <returns></returns> public async Task RegisterNewPerson(string firstName, string lastName, string nationalIdentificationNumber, Gender gender, DateTime birthDate) { if (string.IsNullOrWhiteSpace(firstName)) { throw new ArgumentException("value cannot be empty", nameof(firstName)); } if (string.IsNullOrWhiteSpace(lastName)) { throw new ArgumentException("value cannot be empty", nameof(lastName)); } if (birthDate >= DateTime.Today) { throw new ArgumentException("Birth date cannot be after today", nameof(birthDate)); } var person = Person.Register(firstName, lastName, gender, birthDate); if (!string.IsNullOrWhiteSpace(nationalIdentificationNumber)) { person.SetNationalIdentificationNumber(nationalIdentificationNumber); } Repository.Add(person); await Repository.SaveChangesAsync(); var @event = new PersonRegisteredEvent(person.Id, firstName, lastName, gender, birthDate); EventBus.RaiseEvent(@event); }
/// <summary> /// Implementation of <see cref="ICustomerCommands.RemoveCustomerAccount(Guid)"/> /// </summary> /// <param name="customerId">The customer id</param> /// <returns></returns> public async Task RemoveCustomerAccount(Guid customerId) { if (customerId == Guid.Empty) { throw new ArgumentException("value cannot be empty", nameof(customerId)); } var customer = await Repository.GetByKeyAsync <Customer>(customerId); if (customer == null) { throw new ArgumentOutOfRangeException(nameof(customerId)); } try { var accountId = customer.Account.UserId; string userName = customer.Account.UserName; customer.RemoveAccount(); await AuthClient.DisableAccount(accountId); await Repository.SaveChangesAsync(); var @event = new CustomerAccountRemovedEvent(customerId, userName); EventBus.RaiseEvent(@event); } catch { throw; } }
public async Task <IActionResult> Join([FromBody] GroupMembership membership) { var group = await Repository.Groups .Include(x => x.Members) .FirstOrDefaultAsync(x => x.Id == membership.GroupId); // Can't join non-existant groups. if (group == null) { return(NotFound()); } // Only group owners or the member themselves can manage membership. if (group.OwnerId != User.Id && membership.MemberId != User.Id) { return(Unauthorized()); } // Can't join the same group twice. if (group.Members.Any(x => x == membership)) { return(BadRequest()); } await Repository.GroupMemberships.AddAsync(new GroupMembership { Id = membership.Id, GroupId = membership.GroupId, MemberId = membership.MemberId }); await Repository.SaveChangesAsync(); return(Ok()); }
/// <summary> /// Implementation of <see cref="ICustomerCommands.RegisterNewCompany(string, string, string)"/> /// </summary> /// <param name="companyName">The company name</param> /// <param name="vatNumber">The company vat number</param> /// <param name="nationalIdentificationNumber">The company national identification number</param> /// <returns></returns> public async Task RegisterNewCompany(string companyName, string vatNumber, string nationalIdentificationNumber) { if (string.IsNullOrWhiteSpace(companyName)) { throw new ArgumentException("value cannot be empty", nameof(companyName)); } if (string.IsNullOrWhiteSpace(vatNumber)) { throw new ArgumentException("value cannot be empty", nameof(vatNumber)); } var company = Company.Register(companyName, vatNumber); if (!string.IsNullOrWhiteSpace(nationalIdentificationNumber)) { company.SetNationalIdentificationNumber(nationalIdentificationNumber); } Repository.Add(company); await Repository.SaveChangesAsync(); var @event = new CompanyRegisteredEvent(company.Id, companyName, vatNumber); EventBus.RaiseEvent(@event); }
public async Task <IActionResult> Create([FromBody] Group group) { // Can't create groups for other users. if (group.OwnerId != User.Id) { return(Unauthorized()); } // Don't create the exact same group twice. if (Repository.Groups.Any(x => x.Id == group.Id)) { return(BadRequest()); } await Repository.Groups.AddAsync(new Group { Id = group.Id, Name = group.Name, OwnerId = group.OwnerId }); await Repository.SaveChangesAsync(); return(Ok()); }
public async Task <IActionResult> UpdateData(string id, [FromBody] string data) { if (data == null) { data = ""; } string accid = AuthMan.GetAccountId(this); var ok = await repo.CanUpdateAsync(accid, id); if (ok == false) { return(Forbid()); } var obj = await repo.GetAsync(accid, id); if (obj == null) { return(Forbid()); } obj.Data = data; await repo.SaveChangesAsync(); return(Ok()); }
public static async Task LogAsync(Credentials user, LogActivityType activity, string message) { using (var repo = new Repository()) { var log = repo.Create<activity_log>(); log.action_id = (int) activity; log.credentials_id = Authentication.Credentials.CredId; log.message = message; log.created = await repo.GetNowAsync(); repo.Add(log); await repo.SaveChangesAsync(); } }
public static async Task UpdateRank() { using (var dataContext = new AppServiceDataContext()) { var repository = new Repository(dataContext); var team = await repository.Query<Team>().FirstOrDefaultAsync(); if (team != null) { Console.WriteLine("Loaded team: {0}", team.Id); var random = new Random(); var increment = random.Next(-5, 5); team.Rank += increment; await repository.SaveChangesAsync(); Console.WriteLine("Updated team rank to: {0}", team.Rank); } } }
public static void InitFormContainerActions(TileContainer con) { con.Properties.ItemCheckMode = TileItemCheckMode.Single; var deleteAction = new DelegateAction(() => true, async () => { var checkedTile = con.Items.FirstOrDefault(x => x.Checked.HasValue && x.Checked.Value) as Tile; if (checkedTile == null) return; if (checkedTile.Tag == null) return; int? formId = TagHelper.GetFormDataId(checkedTile.Tag.ToString()); if (!formId.HasValue) return; var view = (WindowsUIView)con.Manager.View; var fly = view.ContentContainers.FindFirst(x => x is Flyout && x.Caption == "Сообщение") as Flyout; var formType = ((Page)checkedTile.ActivationTarget).Document.ControlName; switch (formType) { case "FormData1": case "ArchiveFormData1": case "FormData2": case "ArchiveFormData2": { try { using (var repo = new Repository()) { var data = await repo.GetEduFormDataById(formId.Value); var form = await repo.GetForm(data.form_id); var res = fly != null ? GuiUtility.ShowFlyoutMessage(view, fly, "Подтверждение", string.Format("Удалить форму \"{0}\"?", form), FlyoutCommand.Yes, FlyoutCommand.No) : MessageBox.Show(string.Format("Удалить форму {0}?", form), "Подтверждение", MessageBoxButtons.OKCancel); if (res == DialogResult.No) return; if (await form.IsBlockedAsync()) { var mes = fly != null ? GuiUtility.ShowFlyoutMessage(view, fly, "Информация", "Удаление формы отключено, так как срок сдачи истек.\n" + "Чтобы иметь возможность удалить эту форму, обратитесь к региональному оператору") : MessageBox.Show("Удаление формы отключено, так как срок сдачи истек.\n" + "Чтобы иметь возможность удалить эту форму, обратитесь к региональному оператору", "Информация", MessageBoxButtons.OKCancel); return; } var file = await repo.GetFile(data.file_id); var forms = file.edu_form_data; var tag = TagHelper.GetFormDataTag(TagHelper.TagType.Tile, data); var tiles = con.Items.Find(t => t.Tag.ToString() == tag).ToArray(); repo.RemoveRange(forms); repo.Remove(file); await repo.SaveChangesAsync(); if (con.Items.Count == 1) con.Items.Clear(); else con.Items.RemoveRange(tiles); } } catch (Exception ex) { var mess = fly != null ? GuiUtility.ShowFlyoutMessage(view, fly, "Ошибка удаления", ex.Message) : MessageBox.Show(ex.Message, "Ошибка удаления", MessageBoxButtons.OK); } break; } case "FormData3": case "ArchiveFormData3": case "FormData4": case "ArchiveFormData4": { try { using (var repo = new Repository()) { var data = await repo.GetMunitFormDataById(formId.Value); var form = await repo.GetForm(data.form_id); var res = fly != null ? GuiUtility.ShowFlyoutMessage(view, fly, "Подтверждение", string.Format("Удалить форму \"{0}\"?", form), FlyoutCommand.Yes, FlyoutCommand.No) : MessageBox.Show(string.Format("Удалить форму {0}?", form), "Подтверждение", MessageBoxButtons.OKCancel); if (res == DialogResult.No) return; if (await form.IsBlockedAsync()) { var mes = fly != null ? GuiUtility.ShowFlyoutMessage(view, fly, "Информация", "Удаление формы отключено, так как срок сдачи истек.\n" + "Чтобы иметь возможность удалить эту форму, обратитесь к региональному оператору") : MessageBox.Show("Удаление формы отключено, так как срок сдачи истек.\n" + "Чтобы иметь возможность удалить эту форму, обратитесь к региональному оператору", "Информация", MessageBoxButtons.OKCancel); return; } var file = data.file; var forms = file.municipality_form_data; var tag = TagHelper.GetFormDataTag(TagHelper.TagType.Tile, data); var tiles = con.Items.Find(t => t.Tag.ToString() == tag).ToArray(); repo.RemoveRange(forms); repo.Remove(file); await repo.SaveChangesAsync(); if (con.Items.Count == 1) con.Items.Clear(); else con.Items.RemoveRange(tiles); } } catch (Exception ex) { var mess = fly != null ? GuiUtility.ShowFlyoutMessage(view, fly, "Ошибка удаления", ex.Message) : MessageBox.Show(ex.Message, "Ошибка удаления", MessageBoxButtons.OK); } break; } case "FormData5": case "ArchiveFormData5": case "FormData6": case "ArchiveFormData6": { try { using (var repo = new Repository()) { var data = await repo.GetRegionFormDataById(formId.Value); var res = fly != null ? GuiUtility.ShowFlyoutMessage(view, fly, "Подтверждение", string.Format("Удалить форму \"{0}\"?", data.form), FlyoutCommand.Yes, FlyoutCommand.No) : MessageBox.Show(string.Format("Удалить форму {0}?", data.form), "Подтверждение", MessageBoxButtons.OKCancel); if (res == DialogResult.No) return; var file = data.file; var forms = file.region_form_data; var tag = TagHelper.GetFormDataTag(TagHelper.TagType.Tile, data); var tiles = con.Items.Find(t => t.Tag.ToString() == tag).ToArray(); repo.RemoveRange(forms); repo.Remove(file); await repo.SaveChangesAsync(); if (con.Items.Count == 1) con.Items.Clear(); else con.Items.RemoveRange(tiles); } } catch (Exception ex) { var mess = fly != null ? GuiUtility.ShowFlyoutMessage(view, fly, "Ошибка удаления", ex.Message) : MessageBox.Show(ex.Message, "Ошибка удаления", MessageBoxButtons.OK); } break; } } }) { Caption = "Удалить форму", Type = ActionType.Context, Edge = ActionEdge.Right, Behavior = ActionBehavior.HideBarOnClick }; var searchAction = new DelegateAction(() => true, () => (con.Manager.View as WindowsUIView).ShowSearchPanel()) { Caption = "Поиск", Type = ActionType.Default, Edge = ActionEdge.Left, Behavior = ActionBehavior.HideBarOnClick }; con.Actions.Clear(); con.Actions.Add(deleteAction); con.Actions.Add(searchAction); }
public async Task<IHttpActionResult> PostExcelFile() { var stream = await Request.Content.ReadAsStreamAsync(); IList<Questionary> questionaries; using (var package = new ExcelPackage(stream)) { if (package.Workbook.Worksheets.Count == 0) { throw new InvalidOperationException("Your Excel file does not contain any work sheets"); } var worksheet = package.Workbook.Worksheets.First(); questionaries = FromExcelSheet(worksheet); } if (questionaries.Count == 0) { throw new InvalidOperationException("Excel file is empty"); } using (var repository = new Repository<Questionary>()) { repository.DeleteAll(); foreach (var questionary in questionaries) { repository.Add(questionary); } await repository.SaveChangesAsync(); } return Ok(); }
public async Task<IHttpActionResult> Post(Questionary questionary) { if (!ModelState.IsValid) { return BadRequest(ModelState); } using (var repository = new Repository<Questionary>()) { repository.Add(questionary); await repository.SaveChangesAsync(); return Ok(); } }