/// <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;
}
