public async Task <Guid> Create(LeadModel lead)
{
var entity = _mapper.Map <LeadEntity>(lead);
entity.UserCreated = _currentUser.Id;
var result = await _dbRepository.Add(entity);
await _dbRepository.SaveChangesAsync();
return(result);
}
private int AddLocation(string location)
{
var result = new Location()
{
Name = location
};
_db.Add <Location>(result);
_db.SaveChanges();
return(result.Id);
}
public async Task <long> Create(List <long> userIds)
{
var newChat = await _dbRepository.Add(new Chat());
foreach (var userId in userIds)
{
await _dbRepository.Add(new ChatUsers
{
UserId = userId,
ChatId = newChat
});
}
return(newChat);
}
public IQueryable <Tag> CheckExist(string tags)
{
var tagsAsList = tags.Split(new char[] { ' ', ',' }, StringSplitOptions.RemoveEmptyEntries);
var tagsList = new List <Tag>();
foreach (var tag in tagsAsList)
{
Tag tagFromDb = m_Tags.All().FirstOrDefault(x => x.Name == tag);
if (tagFromDb == null)
{
var tagToAdd = new Tag
{
Name = tag
};
m_Tags.Add(tagToAdd);
m_Tags.Save();
tagsList.Add(tagToAdd);
}
else
{
tagsList.Add(tagFromDb);
}
}
return(tagsList.OrderBy(x => x.Name).AsQueryable());
}
public async Task <ActionResult <AdminDTO> > Register(AdminForCreationDTO admin)
{
try
{
if (!await _adminsRepository.IsEmailFree(admin.Email))
{
return(Conflict());
}
var newAdmin = _mapper.Map <Admin>(admin);
newAdmin.Password = Hash.GetHash(admin.Password);
_dbRepository.Add(newAdmin);
if (await _dbRepository.SaveChangesAsync())
{
return(CreatedAtAction(nameof(GetAdmin), new { adminId = newAdmin.Id }, _mapper.Map <AdminDTO>(newAdmin)));
}
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Database Failure"));
}
return(BadRequest());
}
public async Task <TemplateFile> Create(TemplateFileModel templateFileModel)
{
var existTemplateFile = await _dbRepository
.Get <TemplateFile>()
.FirstOrDefaultAsync(x => x.Link == templateFileModel.Link);
if (existTemplateFile != null)
{
//log
return(null);
}
var templateContent = await FileHelper.Download(templateFileModel.Link);
var fullName = templateFileModel.FullName;
var templateFile = new TemplateFile
{
Fullname = fullName,
Link = templateFileModel.Link,
File = new File
{
Type = FileType.Template,
FullName = fullName,
Content = templateContent
}
};
await _dbRepository.Add(templateFile);
await _dbRepository.SaveChanges();
return(templateFile);
}
public async Task <ActionResult <UserDto> > Register(UserForCreationDto user)
{
try
{
if (await _usersRepository.IsEmailTaken(user.Email))
{
return(Conflict());
}
var newUser = _mapper.Map <User>(user);
newUser.Password = Hash.GetHash(user.Password);
_dbRepository.Add(newUser);
if (await _dbRepository.SaveChangesAsync())
{
return(CreatedAtAction(nameof(GetUser), new { userId = newUser.Id }, _mapper.Map <UserDto>(newUser)));
}
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Database Failure"));
}
return(BadRequest());
}
public async Task <Guid> Create(OrderModel order)
{
var entity = _mapper.Map <OrderEntity>(order);
var result = await _dbRepository.Add(entity);
return(result);
}
public async Task <UserCreateResponse> Create(UserCreate user)
{
var rnd = new Random();
var entity = await _dbRepository.Get <DbUser>().FirstOrDefaultAsync(x => x.Username == user.PhoneNumber);
Guid userId;
if (entity == null)
{
entity = new DbUser(Guid.NewGuid())
{
Username = user.PhoneNumber,
OTP = rnd.Next(10000, 99999).ToString(),
OTPSentTime = DateTime.Now
};
userId = await _dbRepository.Add(entity);
}
else
{
entity.OTP = rnd.Next(10000, 99999).ToString();
entity.OTPSentTime = DateTime.Now;
userId = entity.Id;
await _dbRepository.Update(entity);
}
await _dbRepository.SaveChangesAsync();
return(new UserCreateResponse {
Code = (int)ActionResult.Success,
Message = $"СМС код ({entity.OTP}) отправлен на номер {user.PhoneNumber}",
UserId = userId
});
}
public async Task <ActionResult <ScheduleDto> > NewSchedule(ScheduleForCreationDto schedule)
{
try
{
var userId = int.Parse(User.FindFirst("id").Value);
if (await _schedulesRepository.ScheduleExistsAsync(userId, schedule.Name))
{
return(Conflict());
}
var newSchedule = _mapper.Map <Schedule>(schedule);
newSchedule.UserId = userId;
_dbRepository.Add(newSchedule);
if (await _dbRepository.SaveChangesAsync())
{
return(CreatedAtAction(nameof(GetSchedule), new { scheduleId = newSchedule.Id }, _mapper.Map <ScheduleDto>(newSchedule)));
}
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Database Failure"));
}
return(BadRequest());
}
public int GenerateBattles(IDbRepository<Team> teamsRepository, IDbRepository<Battle> battlesRepository, int competitionId)
{
var teams = teamsRepository.All().Where(x => x.CompetitionId == competitionId).Select(x => new { x.Id }).ToList();
var newBattles = 0;
for (var i = 0; i < teams.Count; i++)
{
for (int j = i + 1; j < teams.Count; j++)
{
var firstTeam = teams[i];
var secondTeam = teams[j];
if (battlesRepository.All().Any(
x =>
(x.FirstTeamId == firstTeam.Id && x.SecondTeamId == secondTeam.Id)
|| (x.FirstTeamId == secondTeam.Id && x.FirstTeamId == firstTeam.Id)))
{
// Battle already exists
continue;
}
newBattles++;
battlesRepository.Add(new Battle { FirstTeamId = firstTeam.Id, SecondTeamId = secondTeam.Id });
}
}
battlesRepository.Save();
return newBattles;
}
public int Add(Irregularity irregularity)
{
irregularities.Add(irregularity);
irregularities.Save();
return(irregularity.Id);
}
public async Task <File> Convert(PrintFormModel printFormModel)
{
var template = await _dbRepository
.Get <TemplateFile>()
.Include(x => x.File)
.FirstOrDefaultAsync(x => x.Link == printFormModel.Template.Link)
?? await _templateService.Create(printFormModel.Template);
var renderedFile = await _renderService.Render(printFormModel, template);
var targetFileName = printFormModel.Template.FullName;
var file = new File
{
Type = FileType.Converted,
FullName = targetFileName,
Content = renderedFile
};
if (file.Content == null)
{
//log
return(null);
}
await _dbRepository.Add(file);
await _dbRepository.SaveChanges();
return(file);
}
public async Task <ActionResult <BookingDTO> > NewBooking(BookingForCreationDTO booking)
{
try
{
if (!await _bookingsRepository.IsRoomVacancyAsync(booking.RoomId, booking.BookingDates))
{
return(Conflict());
}
Booking newBooking = _mapper.Map <Booking>(booking);
newBooking.TotalPrice = await _bookingsRepository.CalculateTotalPrice(booking.RoomId, (int)booking.NumberOfPerson, booking.BookingDates);
_dbRepository.Add(newBooking);
if (await _dbRepository.SaveChangesAsync())
{
return(CreatedAtAction(nameof(GetBooking), new { bookingId = newBooking.Id }, _mapper.Map <BookingDTO>(newBooking)));
}
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Database Failure"));
}
return(BadRequest());
}
public async Task <User> Login(TokenPayloadDTO tokenPayload)
{
var users = await _repository.Find(u => u.UId.Equals(tokenPayload.user_id) && u.Email.Equals(tokenPayload.email));
var user = new User();
var newUser = users.Count() == 0;
if (newUser)
{
user.UId = tokenPayload.user_id;
}
else
{
user = users.First();
}
user.Name = tokenPayload.name;
user.Email = tokenPayload.email;
user.PhotoUrl = tokenPayload.picture;
user.TokenExpirationDate = DateTimeOffset.FromUnixTimeSeconds(tokenPayload.exp).UtcDateTime;
user.LastAccessDate = DateTime.UtcNow;
if (newUser)
{
await _repository.Add(user);
}
else
{
await _repository.Update(user);
}
return(user);
}
public ActionResponse CreateUser(User user)
{
var findUserResponse = _userRepository.Find("UserName", user.UserName, MatchingStrategy.Equals);
if (findUserResponse.Code != AppStatusCode.Ok)
{
return(new ActionResponse
{
Code = findUserResponse.Code,
Message = "Could not create user - existance check failed. Underlying error: " + findUserResponse.Message,
UserMessage = _translator.Translate("global", "generalErrorMessage", _claimContext.UserLanguage)
});
}
if (findUserResponse.Data != null && findUserResponse.Data.Any())
{
return(new ActionResponse
{
Code = AppStatusCode.DuplicateExists,
Message = "A user with the username " + user.UserName + " already exists.",
UserMessage = _translator.Translate("profile", "duplicateUserError", _claimContext.UserLanguage)
});
}
user.OwnedRecipes = new List <string>();
user.LastViewedRecipes = new List <string>();
user.FavoriteRecipes = new List <string>();
user.Settings = new UserSettings {
Language = "sv-SE"
};
return(_userRepository.Add(user));
}
public async Task <Guid> Create(BusModel busModel)
{
var busEntity = _mapper.Map <BusEntity>(busModel);
await _dbRepository.Add(busEntity);
await _dbRepository.SaveChangesAsync();
return(busEntity.Id);
}
public async Task <Guid> Create(ProductModel product)
{
var entity = _mapper.Map <ProductEntity>(product);
var result = await _dbRepository.Add(entity);
await _dbRepository.SaveChangesAsync();
return(result);
}
private void SaveForecast(IDbRepository dbRepository)
{
var entity = new ForecastEntity()
{
Temperature = CurrentWeather.Model.main.temp,
Pressure = CurrentWeather.Model.main.pressure
};
dbRepository.Add(entity);
}
public async Task <Guid> Create(Blog blog)
{
var entity = _mapper.Map <DbBlog>(blog);
var result = await _dbRepository.Add(entity);
await _dbRepository.SaveChangesAsync();
return(result);
}
public bool AddSession(Session session)
{
//TODO: Crazy performance hit just to make sure no duplicate sessionnames is added...
var allSessions = GetAllSessionsWithIncludes().ToList();
var activityToAddSessionTo = _db.Get <Activity>().SingleOrDefault(n => n.Id == session.ActivityId);
if (activityToAddSessionTo == null)
{
return(false);
}
if (allSessions.Any(n => n.Name.ToLower() == session.Name.ToLower() && n.Activity.Name == activityToAddSessionTo.Name))
{
return(false);
}
_db.Add <Session>(session);
return(true);
}
public bool AddParticipantToSession(int participantId, int sessionId)
{
if (!CheckIfParticipantExists(participantId) || !CheckIfSessionExists(sessionId) ||
CheckIfSessionParticipantAlreadyExists(participantId, sessionId))
{
return(false);
}
var result = new SessionParticipant()
{
ParticipantId = participantId,
SessionId = sessionId,
Rating = 0
};
_db.Add <SessionParticipant>(result);
_db.SaveChanges();
return(true);
}
public async Task RegisterView(View view)
{
if (view == null || string.IsNullOrEmpty(view.UserId))
{
throw new ArgumentException("Incorrect View");
}
await _repository.Add(view);
await _repository.SaveChangesAsync();
}
public async Task <long> Send(MessageModel message)
{
var messageEntity = _mapper.Map <Message>(message);
var userId = _currentUser.Id;
var aesKey = _userService.GetAesKey(userId);
messageEntity.EncryptedText = CryptHelper.Encrypt(message.Text, aesKey);
var result = await _dbRepository.Add(messageEntity);
return(result);
}
public async Task <Guid> Create(PlaneModel planeModel)
{
var orderEntity = _mapper.Map <PlaneEntity>(planeModel);
orderEntity.Route = await _dbRepository.Get <RouteEntity>(r => r.Id == planeModel.RouteId).FirstOrDefaultAsync();
await _dbRepository.Add(orderEntity);
await _dbRepository.SaveChangesAsync();
return(orderEntity.Id);
}
public bool AddActivity(Activity activityToAdd)
{
var allActivities = _db.Get <Activity>().ToList();
if (allActivities.Any(n => n.Name.ToLower() == activityToAdd.Name.ToLower()))
{
return(false);
}
_db.Add <Activity>(activityToAdd);
return(true);
}
/// <summary>
/// Добавляет всречу в расписание.
/// </summary>
/// <param name="BeginDateTime">Время начала.</param>
/// <param name="EndDateTime">Время окончания.</param>
/// <param name="NoteDateTime">Время уведомления.</param>
public void Add(DateTime BeginDateTime, DateTime EndDateTime, DateTime?NoteDateTime)
{
Meeting meeting = meetingFactory.Create(BeginDateTime, EndDateTime, NoteDateTime);
if (Validate(meeting, FindAll()))
{
_meetings.Add(meeting);
}
else
{
throw new Exception("Ошибка создания встречи!");
}
}
public ActionResponse AddRecipe(string userId, Recipe recipe)
{
// Verify that user exists
var getUserResponse = _userRepository.Get(userId);
if (getUserResponse.Code != AppStatusCode.Ok || getUserResponse.Data == null)
{
return(new ActionResponse
{
Code = AppStatusCode.EntityNotFound,
Message = "Could not add recipe - failed to get user " + userId + ". Underlying error: " + getUserResponse.Message
});
}
// Set default meta info
recipe.Meta.Created = DateTime.Now;
recipe.Meta.LastEdited = DateTime.Now;
recipe.Meta.Owner = getUserResponse.Data.UserName;
var addRecipeResponse = _recipeRepository.Add(recipe);
if (addRecipeResponse.Code != AppStatusCode.Ok)
{
return(new ActionResponse
{
Code = addRecipeResponse.Code,
Message = addRecipeResponse.Message
});
}
// Add to user's list of owned recipes
var user = getUserResponse.Data;
user.OwnedRecipes.Add(recipe.Id);
var updateUserResponse = _userRepository.Update(user);
if (updateUserResponse.Code != AppStatusCode.Ok)
{
return(new ActionResponse
{
Code = updateUserResponse.Code,
Message = "Could not add recipe - failed to associate new recipe with user."
});
}
return(new ActionResponse {
Code = AppStatusCode.Ok
});
}
public async Task <Guid> Create(RouteModel routeModel)
{
var routeEntity = _mapper.Map <RouteEntity>(routeModel);
routeEntity.Bus = await _dbRepository.Get <BusEntity>(b => b.Id == routeModel.BusId).FirstOrDefaultAsync();
routeEntity.BusDriver = await _dbRepository.Get <BusDriverEntity>(d => d.Id == routeModel.DriverId)
.FirstOrDefaultAsync();
await _dbRepository.Add(routeEntity);
await _dbRepository.SaveChangesAsync();
return(routeEntity.Id);
}
public async Task <int> CreateUser(UserModel newUser)
{
var user = await _dbRepository.GetAll <UserEntity>().Where(x => x.Username == newUser.Username)
.AsNoTracking()
.FirstOrDefaultAsync();
if (user != null)
{
throw new UniqueUsernameException("Username must be unique!");
}
var userEntity = _mapper.Map <UserEntity>(newUser);
await _dbRepository.Add(userEntity);
return(await _dbRepository.SaveChangesAsync());
}
public ActionResult Create(CategoryViewModel model)
{
if (!ModelState.IsValid)
{
return(this.View(model));
}
var newCategory = this.Mapper.Map <Category>(model);
categories.Add(newCategory);
categories.Save();
return(RedirectToAction("Index"));
}
