/// <summary> /// Counts all active occurrences related to this event /// </summary> public static int ActiveOccurrencesCount(EventDto eventDetails) { var occurrencesCount = 0; foreach (EventOccurrenceDto eventOccurrence in eventDetails.EventOccurrences) { if (EventUtils.DetermineOccurrenceStatus(eventOccurrence) == "Active") { occurrencesCount++; } } return occurrencesCount; }
/// <summary> /// Determines if all event occurrences are cancelled for an event /// </summary> public static bool DetermineAllCanceled(EventDto eventDetails) { var allCanceled = true; foreach (EventOccurrenceDto eventOccurrence in eventDetails.EventOccurrences) { var occurrenceStatus = DetermineOccurrenceStatus(eventOccurrence); if (!occurrenceStatus.StartsWith("Can", StringComparison.OrdinalIgnoreCase)) { allCanceled = false; break; } } return allCanceled; }
// PUT api/Event/5 public HttpResponseMessage PutEvent(int id, EventDto eventDto) { if (!ModelState.IsValid) { return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState)); } if (id != eventDto.EventId) { return(Request.CreateResponse(HttpStatusCode.BadRequest)); } Event ev = eventDto.ToEntity(); Schedule schedule = _scheduleRepository.GetById(ev.ScheduleId); if (schedule == null) { return(Request.CreateResponse(HttpStatusCode.NotFound)); } if (schedule.UserId != User.Identity.Name) { // Trying to modify a record that does not belong to the user return(Request.CreateResponse(HttpStatusCode.Unauthorized)); } // Need to detach to avoid duplicate primary key exception when SaveChanges is called _scheduleRepository.Detach(schedule); try { _eventRepository.Save(ev); } catch (DbUpdateConcurrencyException) { return(Request.CreateResponse(HttpStatusCode.InternalServerError)); } return(Request.CreateResponse(HttpStatusCode.OK)); }
public async Task <int> SaveEvent(EventDto eventDetails) { Event eventEntity = new Event(); if (eventDetails.EventId > 0) { eventEntity = _dbContext.Event.Find(eventDetails.EventId); } eventEntity.EventName = eventDetails.EventName; eventEntity.Description = eventDetails.EventDescription; eventEntity.EndTime = eventDetails.EndTime; eventEntity.StartTime = eventDetails.StartTime; eventEntity.EventDate = eventDetails.EventDate; eventEntity.MaxCount = eventDetails.MaxCount.ToInt(); if (eventDetails.EventId == 0) { _dbContext.Event.Add(eventEntity); } await _dbContext.SaveChangesAsync(); return(eventEntity.EventId); }
public async Task <IActionResult> CreateEvent([FromBody] EventDto eventDto) { if (eventDto.Type == EventType.EXCLUSIVE && _scheduleContext.Event.Any(a => a.Type == EventType.EXCLUSIVE && a.Date == eventDto.Date)) { return(Conflict("Exclusive events on the same date.")); } Event @event = new Event(eventDto.Name, eventDto.Type, eventDto.Date, eventDto.Local, eventDto.Participants, eventDto.Status ); _scheduleContext.Add(@event); await _scheduleContext.SaveChangesAsync(); return(Ok(@event)); }
public CrResult <EventDto> EditEvent(long userId, EventDto ev) { var res = new CrResult <EventDto>(); var targetEv = _context.Event.Find(ev.EventId); if (targetEv == null) { res.AddError(new Error(CheckStatus.IdDoesNotExist, nameof(ev.EventId))); return(res); } if (targetEv.channel_id != ev.ChannelId) { res.AddError(new Error(CheckStatus.IdDoesNotExist, nameof(ev.ChannelId))); return(res); } if (new UserRolesManager().CheckPermition(userId, targetEv.channel_id, _editNewsPermitionId)) { targetEv.improtance_id = ev.ImportanceId; targetEv.description = ev.Description; targetEv.event_time = ev.EventTime; targetEv.title = ev.Title; try { _context.SaveChanges(); res.CreatedObject = ev; return(res); } catch (Exception) { res.ActionResult = ActionResult.DatabaseError; return(res); } } else { res.ActionResult = ActionResult.PermissionDenied; return(res); } }
public async Task <GenericResponse> AddEvents(EventDto events) { if (events == null || events?.Events == null) { return(new GenericResponse(false, "Nie podano danych załadunku/rozładunku.")); } try { await unitOfWork.EventRepository.AddEventsAsync(events.Events); } catch (DbUpdateConcurrencyException ex) { return(new GenericResponse(false, ex.InnerException.Message)); } catch (DbUpdateException ex) { return(new GenericResponse(false, ex.InnerException.Message)); } return(new GenericResponse(true, "Załadunki / rozładunki zostały dodane.")); }
private static void Save(IEvent ev) { if (ev == null) { throw new ArgumentNullException("ev"); } var eDto = new EventDto { EventType = ev.EventType, FKGalleryId = ev.GalleryId, TimeStampUtc = ev.TimestampUtc, ExType = ev.ExType, Message = ev.Message, ExSource = ev.ExSource, ExTargetSite = ev.ExTargetSite, ExStackTrace = ev.ExStackTrace, EventData = Serialize(ev.EventData), InnerExType = ev.InnerExType, InnerExMessage = ev.InnerExMessage, InnerExSource = ev.InnerExSource, InnerExTargetSite = ev.InnerExTargetSite, InnerExStackTrace = ev.InnerExStackTrace, InnerExData = Serialize(ev.InnerExData), Url = ev.Url, FormVariables = Serialize(ev.FormVariables), Cookies = Serialize(ev.Cookies), SessionVariables = Serialize(ev.SessionVariables), ServerVariables = Serialize(ev.ServerVariables) }; using (var repo = new EventRepository()) { repo.Add(eDto); repo.Save(); ev.EventId = eDto.EventId; } }
private float TestSinglePrediction(MLContext mlContext, ITransformer model, EventDto eventDto) { Random random = new Random(); var predictionFunction = mlContext.Model.CreatePredictionEngine <EventBuget, EventBugetPrediction>(model); var eventEntity = new EventBuget() { UserId = eventDto.UserId, NumberOfServices = eventDto.NumberOfServices, Participants = eventDto.Participants, BugetNeeded = 0 }; var prediction = predictionFunction.Predict(eventEntity); Console.WriteLine($"**********************************************************************"); Console.WriteLine($"Predicted fare: {prediction.BugetNeeded}, actual fare: 15.5"); Console.WriteLine($"**********************************************************************"); return(prediction.BugetNeeded); }
public async Task <EventDto> UpdateAsync(int id, EventDto dto) { var currentEvent = await _unitOfWork?.Events?.Query .Include(e => e.FileUnit) .Include(e => e.ContentList) .SingleOrDefaultAsync(e => e.Id == id); if (currentEvent == null) { return(null); } currentEvent.EventType = dto.EventType; currentEvent.EventDate = dto.EventDate; currentEvent.IsDeleted = dto.IsDeleted; currentEvent.FileUnit.Name = dto.FileUnit.Name; currentEvent.FileUnit.Description = dto.FileUnit.Description; currentEvent.ContentList.Clear(); var contentList = new List <EventContent>(); contentList.AddRange(dto.ContentList. Select(c => new EventContent { Name = c.Name, Description = c.Description, IsDeleted = c.IsDeleted, CreatedAt = DateTime.Now, LastModified = DateTime.Now, ContentType = c.ContentType, Content = c.Content, Order = c.Order })); currentEvent.ContentList = contentList; await _unitOfWork.SaveChangesAsync(); return(dto); }
public async Task <ServiceStatus> CreateRoutineEvents(EventDto newEvent) { var daysOfWeek = newEvent.DaysOfWeek; if (daysOfWeek != null) { foreach (var day in newEvent.DaysOfWeek) { switch (day) { case (1): await CreateRoutineEvent(newEvent, DayOfWeek.Monday); break; case (2): await CreateRoutineEvent(newEvent, DayOfWeek.Tuesday); break; case (3): await CreateRoutineEvent(newEvent, DayOfWeek.Wednesday); break; case (4): await CreateRoutineEvent(newEvent, DayOfWeek.Thursday); break; case (5): await CreateRoutineEvent(newEvent, DayOfWeek.Friday); break; } } } return(ServiceStatus.Success); }
public async Task <ActionResult <EventDto> > Get(int id) { var eventInfo = await _eventInfoService.GetEventInfoByIdAsync(id); if (eventInfo == null) { return(NotFound()); } var dto = new EventDto() { Id = eventInfo.EventInfoId, Name = eventInfo.Title, Slug = eventInfo.Code, Description = eventInfo.Description, StartDate = eventInfo.DateStart, EndDate = eventInfo.DateEnd, Featured = eventInfo.Featured }; return(Ok(dto)); }
public async Task Get_published_events_with_filter_by_date(EventDto entity) { //Arrange var eventService = _container.Resolve <IEventService>(); var isFiltered = true; var culture = "en"; //Act var events = await eventService.GetPublishedEvents(FilterEventOptions.Date, entity.Date.ToString(CultureInfo.CreateSpecificCulture(culture)), culture); events.ToList().ForEach(x => { if (x.Event.Date.Date != entity.Date.Date) { isFiltered = false; } }); //Assert Assert.IsTrue(isFiltered); }
public static async Task <IActionResult> Run( [HttpTrigger(AuthorizationLevel.Function, methods: "post", Route = null)] EventDto eventDto, [DurableClient] IDurableOrchestrationClient starter, ILogger log) { var validator = new EventDtoValidator(); var validationResult = await validator.ValidateAsync(eventDto); if (!validationResult.IsValid) { return(new BadRequestObjectResult( validationResult.Errors.Select(e => new ModelErrorResult(e.PropertyName, e.ErrorMessage)))); } var instanceId = await starter.StartNewAsync(nameof(RunOrchestrator), eventDto); log.LogInformation($"Started orchestration with ID = '{instanceId}'."); var status = await starter.GetStatusAsync(instanceId); while (status.RuntimeStatus != OrchestrationRuntimeStatus.Completed) { await Task.Delay(1000); status = await starter.GetStatusAsync(instanceId); if ((status.RuntimeStatus == OrchestrationRuntimeStatus.Failed) || (status.RuntimeStatus == OrchestrationRuntimeStatus.Terminated) || (status.RuntimeStatus == OrchestrationRuntimeStatus.Canceled)) { throw new FunctionFailedException("Orchestration failed with error: " + status.Output); } } return(new ObjectResult(status.Output) { StatusCode = StatusCodes.Status201Created }); }
public async Task <IActionResult> PutEvent(ulong id, UpdateEventDto updateEventDto) { if (!IsAdmin() && updateEventDto.Creator != Convert.ToUInt64(UserId)) { return(Unauthorized("You can not update an event for another user.")); } try { EventDto eventDto = await _business.Update <EventDto, UpdateEventDto>(id, updateEventDto, (eventEntity => IsAdmin() || eventEntity.Creator == Convert.ToUInt64(UserId))); return(Ok(eventDto)); } catch (ArgumentNullException) { return(BadRequest($"An event with id \"{id}\" was not found.")); } catch (ConditionFailedException) { return(Unauthorized("You can not update an event for another user.")); } }
public async Task Create_event() { //Arrange var add = new EventDto { LayoutId = 2, Date = DateTime.Today.AddMonths(1).AddHours(21).AddMinutes(30), Description = "The highpoint of Andris Nelsons’ final season as the CBSO’s music director – a concert performance of Wagner’s final music drama of almost alarming maturity", Title = "Parsifal", ImageURL = "url", CreatedBy = 1 }; //Act await eventService.Create(add); insertedId = add.Id; var insertedRow = await eventService.Get(insertedId); //Assert Assert.AreEqual(add, insertedRow); }
public IHttpActionResult PutEvent(EventDto event1) { try { int x = BLL.EventService.UpdateEvent(event1); if (x == 0) { return(NotFound()); } else { return(Ok(x)); } } catch (Exception e) { //שקרא לה תפס אותה וגם הוא זרק אותהbll היא נזרקה ואז הdal במקרה שגיאה ב //תפס את השגיאה והוא מעביר את טקסט השגיאה ללקוחbll שהפעיל את הwebapi ה //האנגולר יוכל לראות שחזר שגיאה ומה הייתה השגיאה return(BadRequest(e.Message)); } }
public EventInfo(EventDto dto) { if (dto == null) { throw new ArgumentNullException("dto"); } Id = dto.Id; OwnerId = dto.OwnerId; Importance = dto.Importance; Count = dto.Count; StartDate = dto.StartDate; EndDate = dto.EndDate; JoinKeyHash = dto.JoinKeyHash; TypeId = dto.TypeId; TypeSystemName = dto.TypeSystemName; TypeDisplayName = dto.TypeDisplayName; TypeCode = dto.TypeCode; Message = dto.Message; Version = dto.Version; Category = dto.Category; IsUserHandled = dto.IsUserHandled; Properties = DataConverter.GetExtentionPropertyCollection(dto.Properties); }
public bool Create(EventDto dto) { SqlCommand cmd = new SqlCommand("Insert Into tblEvent(name,description,emailContent,userID, status) VALUES(@name,@description,@emailContent,@userID,@status);", con); cmd.Parameters.AddWithValue("@name", dto.Name); cmd.Parameters.AddWithValue("@description", dto.Description); cmd.Parameters.AddWithValue("@emailContent", dto.EmailContent); cmd.Parameters.AddWithValue("@userID", dto.UserID); cmd.Parameters.AddWithValue("@status", "new"); int count = 0; try { con.Open(); count = cmd.ExecuteNonQuery(); } finally { con.Close(); } return(count == 1); }
public static BasketLineDto From(BasketLine entity) { EventDto @event = null; if (entity.Event != null) { @event = new EventDto { Date = entity.Event.Date, EventId = entity.Event.Id, Name = entity.Event.Name, }; } return(new BasketLineDto { Event = @event, Price = entity.Price, BasketId = entity.BasketId, TicketAmount = entity.TicketAmount, BasketLineId = entity.Id, }); }
public IHttpActionResult FindEventForDonation(int id) { //Finds the first Event which has any Projects that match the inputed Project Id. Event Event = db.Events .Where(d => d.Donations.Any(p => p.DonationID == id))//Donations only functional once put into Event Model .FirstOrDefault(); //if not found, return 404 status code. if (Event == null) { return(NotFound()); } //put into a 'Data Transfer Object' EventDto EventDto = new EventDto { //All that is needed for the selection EventId = Event.EventId, Title = Event.Title }; //pass along data as 200 status code OK response return(Ok(EventDto)); }
public ActionResult <EventDto> CreateEvent(EventDto dto) { if (dto.Occurs < DateTimeOffset.UtcNow) { return(BadRequest()); } var venue = dataContext.Set <Venue>().SingleOrDefault(x => x.Id == dto.VenueId); if (venue == null) { return(BadRequest()); } var adding = dataContext.Set <Event>().Add(new Event { Name = dto.Name, University = dto.University, Occurs = dto.Occurs, VenueId = dto.VenueId, VenueName = venue.Name, CreatedByUserId = User.GetCurrentUserId() ?? throw new Exception("should have user id") });
public void IndexShould_ReturnExpectedModel() { // Arrange var eventServiceMock = new Mock <IEventService>(); var eventDto1 = new EventDto() { Id = 1, Name = "Test", OddsForFirstTeam = 1, OddsForDraw = 2, OddsForSecondTeam = 3, StartDate = DateTime.Now }; var eventDto2 = new EventDto() { Id = 2, Name = "Test2", OddsForFirstTeam = 4, OddsForDraw = 5, OddsForSecondTeam = 6, StartDate = DateTime.Now }; eventServiceMock.Setup(x => x.GetAll()).Returns(new List <EventDto>() { eventDto1, eventDto2 }); var controller = new EventController(eventServiceMock.Object); // Act var result = controller.Index() as ViewResult; // Assert Assert.AreEqual(2, result.ViewEngineCollection.Count); }
public async Task Update(EventDto entity) { if (entity == null) { throw new ArgumentNullException(); } if (entity.LayoutId <= 0) { throw new EventException("LayoutId is invalid"); } if (!IsDateValid(entity, false)) { throw new EventException("Invalid date"); } if (IsPastDate(entity)) { throw new EventException("Attempt of updating event with a date in the past"); } var update = await _context.EventRepository.GetAsync(entity.Id); if (update.LayoutId != entity.LayoutId && HasLockedSeats(entity.Id)) { throw new EventException("Not allowed to update layout. Event has locked seats"); } update.Title = entity.Title; update.LayoutId = entity.LayoutId; update.ImageURL = entity.ImageURL; update.Description = entity.Description; update.Date = entity.Date; _context.EventRepository.Update(update); await _context.SaveAsync(); }
public async Task <ActionResult <int> > CreateEvent(EventDto newEvent) { var currUser = await _userRepository.GetUserByUsernameAsync(User.GetUsername()); var events = await _eventsRepository.GetAllEvents(); var matchingDates = events.Where(e => e.Date == newEvent.Date); var matchingEvents = matchingDates.Where(e => e.Name == newEvent.Name); if (matchingEvents.Count() > 0) { return(BadRequest("Event already exists!")); } var createdEvent = new Event { Name = newEvent.Name, Date = newEvent.Date, Location = newEvent.Location, Creator = currUser, CreatorId = currUser.Id }; var userEvent = new UserEvents { OrganiserId = currUser.Id, EventId = createdEvent.Id }; createdEvent.Organisers = new List <UserEvents>(); createdEvent.Organisers.Add(userEvent); return(await _eventsRepository.CreateEvent(createdEvent)); }
public EventInputDto ConfigureEventBeforeCreation(int layoutId) { var venueId = _layoutService.Get(layoutId).VenueId; var venueDescription = _venueService.Get(venueId).Description; var layoutDescription = _layoutService.Get(layoutId).Description; var areas = _areaService.List(area => area.LayoutId == layoutId).ToList(); var eventAreas = _mapper.Map <List <EventAreaDto> >(areas); var @event = new EventDto { LayoutId = layoutId, Date = DateTime.Now.AddDays(1), }; var newEventInput = new EventInputDto { VenueDescriptionValue = venueDescription, LayoutDescriptionValue = layoutDescription, Event = @event, EventAreas = eventAreas, }; return(newEventInput); }
public async Task CreateEventAsync(EventDto eventDto) { if (eventDto != null) { var allEvents = _repositoryEvent.GetAllWithoutTracking(); if (allEvents.FirstOrDefault(ev => ev.Name == eventDto.Name) != null) { throw new OtherException <string>(ExceptionResource.NameAlreadyExist); } else { eventDto.Created = DateTime.UtcNow; eventDto.PFreeNumber = eventDto.PNumber; var userEvent = _mapper.Map <Event>(eventDto); await _repositoryEvent.AddAsync(userEvent); await _repositoryEvent.SaveChangesAsync(); } } else { throw new OtherException <string>(ExceptionResource.NotCreated); } }
public OkObjectResult NewEvent([FromBody] EventDto dto) { var userId = GetUserId(); var ev = new Event { Name = dto.Name, Location = dto.Location, CreatedByUserId = userId, DateAndTime = dto.DateAndTime }; _context.Events.Add(ev); _context.EventModerators.Add(new EventModerator { EventId = ev.EventId, UserIdRecipient = userId, UserIdRequester = userId, Status = RequestStatus.Accepted }); _context.SaveChanges(); return(new OkObjectResult(new { success = true, eventId = ev.EventId })); }
public IActionResult add(EventModel model, IFormFile file = null, IFormFile form = null) { try { if (ModelState.IsValid) { EventDto dto = new EventDto(); dto.event_id = model.event_id; dto.title = model.title; if (file != null) { dto.image_name = _fileHelper.saveImageAndGetFileName(file, model.title); } if (form != null) { dto.file_name = _fileHelper.saveFileAndGetFileName(form, model.title); } dto.event_from_date = model.event_from_date; dto.event_to_date = model.event_to_date; dto.description = model.description; dto.is_closed = dto.is_closed; dto.time = model.time; dto.venue = model.venue; _eventService.save(dto); AlertHelper.setMessage(this, "Event saved successfully.", messageType.success); return(RedirectToAction("index")); } } catch (Exception ex) { AlertHelper.setMessage(this, ex.Message, messageType.error); return(RedirectToAction("new")); } return(View(model)); }
public ActionResult Create([Bind(Include = "Title, StartDateTime, Location, InviteByEmail,Description,Duration,IsPublic")] EventInputModel model) { try { // Validation if (model != null && this.ModelState.IsValid) { var e = new EventDto() { AuthorId = this.User.Identity.GetUserId(), Title = model.Title, StartDateTime = model.StartDateTime, Duration = model.Duration, Description = model.Description, Location = model.Location, IsPublic = model.IsPublic, InvitedEmails = model.InviteByEmail }; // Adding of EventDto to Service Layer eventService.AddEventDto(e); eventService.SaveChanges(); this.AddNotification("Event created.", NotificationType.INFO); return(this.RedirectToAction("Index")); } } catch (DataException /* dex */) { //Log the error (uncomment dex variable name and add a line here to write a log. ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists see your system administrator."); } return(this.View(model)); }
public EventDto GetById(int event_id) { try { var @event = _eventRepository.GetById(event_id); if (@event == null) { _logger.LogError($"Event with id: {event_id}, hasn't been found in db."); return(null); } _logger.LogInfo($"Returned Event with id: {event_id}"); EventDto eventDto = _mapper.Map <EventDto>(@event); return(eventDto); } catch (Exception ex) { _logger.LogError($"Something went wrong inside GetEventById action: {ex.Message}"); throw new Exception(); } }
public void AddShould_ReturnExpectedView() { // Arrange var eventServiceMock = new Mock <IEventService>(); var eventDto = new EventDto() { Id = 1, Name = "Test", OddsForFirstTeam = 1, OddsForDraw = 2, OddsForSecondTeam = 3, StartDate = DateTime.Now }; eventServiceMock.Setup(x => x.Add()).Returns(eventDto); var controller = new EventController(eventServiceMock.Object); // Act var result = controller.Add() as PartialViewResult; // Assert Assert.AreEqual("AddPartial", result.ViewName); }
private async Task<string> CreateUpdateEvent(CreateCouponViewModel couponVm, string eventStatus, IMyMentorRepository repository) { var json = new JavaScriptSerializer(); CurrencyDto currentCurrency = null; var eventDto = new EventDto { ObjectId = couponVm.EventId, EventStatus = eventStatus, EventType = EventTypes.CouponPurchase, UserId = couponVm.TeacherData.TeacherId, CouponId = couponVm.CouponId, PaymentData = couponVm.PaymentData, EventData = json.Serialize(couponVm), PaymentAmount = couponVm.TeacherData.AmountForPayment, PaymentAmountNIS = ConvertToNis(couponVm.TeacherData.AmountForPayment, out currentCurrency), }; eventDto.PaymentCurrency = currentCurrency; return await repository.CreateUpdateEvent(eventDto); }
public static IEvent MapToEvent(EventDto eventDto) { return Mapper.Map<Event>(eventDto); }
private static void UpdateCouponAccountStatementsAndEvent( CreateCouponViewModel createCouponVm, IMyMentorRepository repository, IEnumerable<AccountStatement> accountStatementsToUpdate, EventDto eventsDto) { var accountStatementsWithCreditOrDebit = accountStatementsToUpdate.Where(x => x.Credit > 0 || x.Debit > 0).ToArray(); var couponUpdate = ParseObject.CreateWithoutData<Coupon>(createCouponVm.CouponId); couponUpdate.CouponStatus = BL.Consts.CouponStatus.Active; // update account statements repository.BulkSave(accountStatementsWithCreditOrDebit.Union(new ParseObject[] { couponUpdate })); // set users balance foreach (var accountStatement in accountStatementsWithCreditOrDebit) { var user = Task.Run(() => repository.FindUsersById(new[] {accountStatement.User.ObjectId})).Result.SingleOrDefault(); if (user != null) { var userAdminData = user.GetPointerObject<UserAdminData>("adminData"); if (userAdminData != null) { userAdminData.Balance = accountStatement.Balance; userAdminData.BalanceNis = CurrencyConverter.ConvertToNis(accountStatement.Balance,accountStatement.Currency.ConvertToCurrencyDto(),repository); Task.Run(() => userAdminData.SaveAsync()).Wait(); } } } eventsDto.EventStatus = EventStatus.EventPaymentCompleted; Task.Run(() => repository.CreateUpdateEvent(eventsDto)).Wait(); }
//public async Task FixRecords() //{ // var results = // (await new ParseQuery<AccountStatement>().WhereEqualTo("currency", ParseObject.CreateWithoutData<Currency>("PrOfDBWHGg")).FindAsync()).ToArray(); // foreach (var result in results) // { // result["currency"] = ParseObject.CreateWithoutData<Currency>("K67StSNEYs"); // await result.SaveAsync(); // } //} private void HandlePaymentRequiredRecovery(CreateCouponViewModel createCouponVm, EventDto eventsDto, IMyMentorRepository repository, CurrencyRetriver currencyRetriever, CurrencyDto currentCurrency) { if (createCouponVm.PaymentRequired && string.IsNullOrEmpty(createCouponVm.PaymentData)) { var coupon = ParseObject.CreateWithoutData<Coupon>(createCouponVm.CouponId); coupon.CouponStatus = BL.Consts.CouponStatus.Pending; coupon.SaveAsync(); UpdatePaymentNotRecieved(eventsDto, repository); return; } var accountStatementBuilder = new AccountStatementBuilder(repository, currencyRetriever) { CouponId = createCouponVm.CouponId, EventId = createCouponVm.EventId }; var missingAccountStatements = GetMissingAccountStatements(createCouponVm, eventsDto); var accountStatementsByUser = missingAccountStatements.GroupBy(x=>x.UserId); var accountStatementsToUpdate = new List<AccountStatement>(); foreach (var accountStatementByUser in accountStatementsByUser) { var user = Task.Run(() => { var userId = accountStatementByUser.Key; return repository.FindUserWithAdminData(userId); }).Result; foreach (var accountStatement in accountStatementByUser) { var transactionCode = repository.FindTransactionTypesById(accountStatement.TransactionTypeId).TransactionCode; var asCurrency = repository.FindAllCurrencies(accountStatement.CurrencyId); var accountStatementDto = Task.Run(() => accountStatementBuilder.SetAccountStatement(user, accountStatement.Credit, accountStatement.Debit, transactionCode, accountStatement.DueDate, asCurrency.Single(), validationToken: accountStatement.ValidationToken)).Result; accountStatementDto.Order = accountStatement.Order; accountStatementsToUpdate.Add(accountStatementDto.ConvertToAccountStatementDomain()); } } UpdateCouponAccountStatementsAndEvent(createCouponVm, repository, accountStatementsToUpdate, eventsDto); }
private static IEnumerable<AccountStatementDto> GetMissingAccountStatements( CreateCouponViewModel createCouponVm, EventDto eventsDto) { var accountStatementsInEvent = createCouponVm.AccountStatements; AccountStatement[] storedAccountStatements = Task.Run(() => new ParseQuery<AccountStatement>() .WhereEqualTo("event", ParseObject.CreateWithoutData<Event>(eventsDto.ObjectId)) .FindAsync()).Result.ToArray(); var storedAccountStatementsDto = storedAccountStatements.Select(x => x.ConvertToAccountStatementDto()); IEnumerable<AccountStatementDto> missingAccountStatements = accountStatementsInEvent.Except(storedAccountStatementsDto); return missingAccountStatements; }
private static void UpdatePaymentNotRecieved(EventDto eventsDto, IMyMentorRepository repository) { //payment was not recieved eventsDto.EventStatus = EventStatus.PaymentNotReceived; repository.CreateUpdateEvent(eventsDto); }
private static CreateCouponViewModel CreateCouponViewModel(EventDto eventsDto) { var js = new JavaScriptSerializer(); var eventData = eventsDto.EventData; var createCouponVm = js.Deserialize<CreateCouponViewModel>(eventData); return createCouponVm; }