public async Task <IActionResult> Put(int id, Company Company)
{
if (id != Company.Id)
{
return(BadRequest());
}
_context.Entry(Company).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CompanyExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task CreateUser(UserCreationRequest userCreationRequest)
{
var userToCheckNick = await _rep.GetUserByNickname(userCreationRequest.NickName);
var userToCheckEmail = await _rep.GetUserByEmail(userCreationRequest.Email);
Check.Value(userToCheckNick, "create user")
.IsNull(ErrorMessages.UserWithNicknameExistsMsg(userCreationRequest.NickName));
Check.Value(userToCheckEmail, "create user")
.IsNull(ErrorMessages.UserWithEmailExistsMsg(userCreationRequest.Email));
Check.Value(userCreationRequest.Password, "password").IsPassword();
var count = await _dbContext.Users.CountAsync();
var user = _mapper.Map <User>(userCreationRequest);
user.Id = count + 1;
user.Guid = Guid.NewGuid();
_dbContext.Users.Add(user);
var salt = PasswordGenerator.GenerateSalt();
var pass = PasswordGenerator.HashPassword(userCreationRequest.Password, salt);
_dbContext.Credentials.Add(new HashedCredential()
{
UserId = user.Id,
Salt = salt,
HashedPassword = pass
});
await _dbContext.SaveChangesAsync();
}
public async Task <IActionResult> PutDepartment(int id, DepartmentDTO departmentDTO)
{
if (id != departmentDTO.DepartmentId)
{
return(BadRequest());
}
_context.Entry(DTOToDepartment(departmentDTO)).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DepartmentExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutCompany([FromRoute] int id, [FromBody] Company company)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != company.CompanyId)
{
return(BadRequest());
}
_context.Entry(company).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CompanyExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutManager([FromRoute] int id, [FromBody] Manager manager)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != manager.ManagerID)
{
return(BadRequest());
}
_context.Entry(manager).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ManagerExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> Post([FromBody] Employment employment)
{
_db.Add(employment);
await _db.SaveChangesAsync();
return(Ok(employment));
}
public async Task <IActionResult> PutEmployee(int id, EmployeeDTO employeeDTO)
{
if (id != employeeDTO.EmployeeId)
{
return(BadRequest());
}
_context.Entry(DTOToEmployee(employeeDTO)).State =
EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EmployeeExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task SeedAsync(bool isVatRegistered)
{
await SeedQuantityTypesAsync();
await SeedPaymentTypesAsync();
await SeedVatTypesAsync(isVatRegistered);
await companyDbContext.SaveChangesAsync();
}
public async Task <int> AddCompany(CompanyDto companyDto)
{
CompanyEntity companyEntity = new CompanyEntity(companyDto);
await companyDbContext.Companies.AddAsync(companyEntity);
await companyDbContext.SaveChangesAsync();
return(companyEntity.Id);
}
public async Task <Department> CreateDataAsync(Department entity)
{
// adding a new entity in DbSet
var result = await context.Departments.AddAsync(entity);
// commit trsnsaction
await context.SaveChangesAsync();
return(result.Entity); // returned the commit entity
}
public async Task <IActionResult> Create([Bind("Type,Description,IsActive,IsDeleted,DeletedOn,Id,CreatedOn,ModifiedOn")] QuantityType quantityType)
{
if (ModelState.IsValid)
{
_context.Add(quantityType);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(quantityType));
}
public async Task <IActionResult> Create([Bind("Id,Name,Desc")] ConfigurationValue configurationValue)
{
if (ModelState.IsValid)
{
_context.Add(configurationValue);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(configurationValue));
}
public async Task <IActionResult> Create([Bind("ClienteId,RIF,RazonSocial")] Cliente cliente)
{
if (ModelState.IsValid)
{
_context.Add(cliente);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(cliente));
}
public async Task <IActionResult> Post([FromBody] Person person)
{
// NOTE TransactionSCope wouldn't work here for some reason. EF "doesn't support ambient transactions".
using (var tx = new TransactionScope(TransactionScopeOption.Suppress, TransactionScopeAsyncFlowOption.Enabled))
{
Db.Database.BeginTransaction(System.Data.IsolationLevel.Serializable);
person.EmployeeNum = BuildEmpNum(person.LastName);
Db.Add(person);
await Db.SaveChangesAsync();
Db.Database.CommitTransaction();
return(Ok(person));
}
}
public async Task <IActionResult> ReviewForm(ReviewViewModel model)
{
Review review = new Review()
{
Name = string.IsNullOrEmpty(model.Name) ? "Unknown" : model.Name,
ReviewText = model.Review
};
await _context.Reviews.AddAsync(review);
await _context.SaveChangesAsync();
return(RedirectToAction("Review"));
}
public async Task <IActionResult> Seed()
{
using (var ctx = new CompanyDbContext())
{
var company = new Company
{
CompanyName = "Company 1",
Ein = "123456789",
Employees = new List <Employee>
{
new Employee
{
FirstName = "John",
LastName = "Doe"
},
new Employee
{
FirstName = "Jane",
LastName = "Doe"
}
}
};
ctx.Companies.Add(company);
await ctx.SaveChangesAsync();
}
return(View());
}
public async Task <IActionResult> MyForm(TrinerRequestModel model)
{
var tempImage = System.Drawing.Image.FromStream(model.Avatar.OpenReadStream());
var result = Utility.ResizeImage(tempImage, 308, 173);
var base64 = string.Format("data:image/jpg; base64, {0}", Convert.ToBase64String(Utility.ImageToByte2(result)));
var newRequest = new TrinerRequest()
{
Name = model.Name,
SurName = model.SurName,
Phone = model.Phone,
Email = string.IsNullOrEmpty(model.Email) ? string.Empty : model.Email,
About = model.About,
MyRequest = model.MyRequest,
Avatar = base64,
Accept = false
};
await _context.TrinerRequests.AddAsync(newRequest);
await _context.SaveChangesAsync();
if (newRequest.Accept == false)
{
string strMsg = "Your application is under review. We will post it as soon as possible. ";
string script = "<script language=\"javascript\" type=\"text/javascript\">alert('" + strMsg + "'); window.location='TrinerRequestIndex'; </script>";
await Response.WriteAsync(script);
return(RedirectToAction("TrinerRequestIndex"));
}
else
{
return(RedirectToAction("TrinerRequestIndex"));
}
}
public async Task DeleteCompany(int id)
{
var foundCompany = await this.companyDbContext.Companies.FirstOrDefaultAsync(company => company.Id == id);
companyDbContext.Companies.Remove(foundCompany);
await companyDbContext.SaveChangesAsync();
}
/// <summary>
/// Overwrites an existing record in database with given one.
/// </summary>
/// <param name="updatedRecord">Previously modified object.</param>
/// <returns></returns>
public async Task UpdateRecordAsync(T updatedRecord)
{
using (var companyDb = new CompanyDbContext())
{
companyDb.Entry(updatedRecord).State = EntityState.Modified;
await companyDb.SaveChangesAsync().ConfigureAwait(false);
}
}
/// <summary>
/// Adds record to the database.
/// </summary>
/// <param name="record">Record of given type.</param>
/// <returns></returns>
public async Task AddAsync(T record)
{
using (var companyDb = new CompanyDbContext())
{
companyDb.Set <T>().Add(record);
await companyDb.SaveChangesAsync().ConfigureAwait(false);
}
}
/// <summary>
/// Adds a collection of records to the database.
/// </summary>
/// <param name="records">An enumerable collection of records of given type.</param>
/// <returns></returns>
public async Task AddAsync(IEnumerable <T> records)
{
using (var companyDb = new CompanyDbContext())
{
companyDb.Set <T>().AddRange(records);
await companyDb.SaveChangesAsync().ConfigureAwait(false);
}
}
public async Task <IActionResult> ProblemForm(ProblemViewModel model)
{
var tempImage = System.Drawing.Image.FromStream(model.Avatar.OpenReadStream());
var result = Utility.ResizeImage(tempImage, 245, 255);
var base64 = string.Format("data:image/jpg; base64, {0}", Convert.ToBase64String(Utility.ImageToByte2(result)));
var Problem = new Problem()
{
ProblemImage = base64,
Description = model.Description,
Solution = model.Solution,
Level = model.Level
};
await _context.Problems.AddAsync(Problem);
await _context.SaveChangesAsync();
return(RedirectToAction("ProblemIndex")); //TODO
}
/// <summary>
/// Resets assigned employee of specified room key to null value.
/// </summary>
/// <param name="key">Target room key.</param>
/// <returns></returns>
public async Task TakeTheRoomKeyAsync(RoomKey key)
{
using (CompanyDbContext companyDb = new CompanyDbContext())
{
key.ChangeAssignedEmployee(null);
companyDb.Entry(key).State = EntityState.Modified;
await companyDb.SaveChangesAsync().ConfigureAwait(false);
}
}
/// <summary>
/// Resets assigned employee of room keys collection to null value.
/// </summary>
/// <param name="keys">Target collection of room keys.</param>
/// <returns></returns>
public async Task TakeMultipleRoomKeysAsync(IEnumerable <RoomKey> keys)
{
using (CompanyDbContext companyDb = new CompanyDbContext())
{
foreach (RoomKey key in keys)
{
key.ChangeAssignedEmployee(null);
companyDb.Entry(key).State = EntityState.Modified;
}
await companyDb.SaveChangesAsync().ConfigureAwait(false);
}
}
/// <summary>
/// Removes given collection of records from the database.
/// </summary>
/// <param name="records"></param>
/// <returns></returns>
public async Task RemoveAsync(IEnumerable <T> records)
{
using (var companyDb = new CompanyDbContext())
{
foreach (T record in records)
{
companyDb.Set <T>().Attach(record);
}
companyDb.Set <T>().RemoveRange(records);
await companyDb.SaveChangesAsync().ConfigureAwait(false);
}
}
public async Task <IActionResult> MyForm(RequestModel model)
{
//if (!ModelState.IsValid)
// return View(model);
try
{
var tempImage = System.Drawing.Image.FromStream(model.Avatar.OpenReadStream());
var result = Utility.ResizeImage(tempImage, 308, 173);
var base64 = string.Format("data:image/jpg; base64, {0}", Convert.ToBase64String(Utility.ImageToByte2(result)));
var newRequest = new Request()
{
Name = model.Name,
SurName = model.SurName,
Phone = model.Phone,
Email = User.Identity.Name,
About = model.About,
MyRequest = model.MyRequest,
BankAccount = model.BankAccount,
Avatar = base64,
Accept = false
};
await _context.Requests.AddAsync(newRequest);
await _context.SaveChangesAsync();
IEnumerable <Request> request = _context.Requests;
if (newRequest.Accept == false)
{
string strMsg = "Your application is under review. We will post it as soon as possible. ";
string script = "<script language=\"javascript\" type=\"text/javascript\">alert('" + strMsg + "'); window.location='RequestIndex'; </script>";
await Response.WriteAsync(script);
return(RedirectToAction("RequestIndex"));
}
else
{
return(RedirectToAction("RequestIndex"));
}
}
catch (Exception ex)
{
string strMsg = "Something Went Wrong or not all required fileds are filled try again";
string script = "<script language=\"javascript\" type=\"text/javascript\">alert('" + strMsg + "'); window.location='MyForm'; </script>";
await Response.WriteAsync(script);
return(View());
}
}
public async Task <bool> InviteDeveloperToProject(int developerId, int projectId)
{
using (CompanyDbContext context = CompanyDbContext.Create())
{
var entity = new ProjectDeveloper
{
DeveloperId = developerId,
ProjectId = projectId
};
context.ProjectDeveloper.Add(entity);
await context.SaveChangesAsync();
return(true);
}
}
/// <summary>
/// Saves the company data to the temporary company table
/// </summary>
/// <param name="temporaryCompany"></param>
/// <returns></returns>
public async Task SaveCompanyDataToTemporaryTable(TemporaryCompanyTemplate temporaryCompany)
{
try
{
_context.Add(temporaryCompany);
await _context.SaveChangesAsync();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
public async Task <Developer> CreateAsync(string firstName, string lastName, DateTime workedFrom)
{
using (CompanyDbContext context = CompanyDbContext.Create())
{
var entity = new Dal.Entitites.Developer
{
FirstName = firstName,
LastName = lastName,
WorkedFrom = workedFrom
};
context.Developer.Add(entity);
await context.SaveChangesAsync();
return(ToDomain(entity));
}
}
public string Registration(RegistrationRequestModel model)
{
string script = string.Empty;
try
{
var tempImage = System.Drawing.Image.FromStream(model.Avatar.OpenReadStream());
var result = Utility.ResizeImage(tempImage, 300, 300);
var base64 = string.Format("data:image/jpg; base64, {0}", Convert.ToBase64String(Utility.ImageToByte2(result)));
var newRequest = new RegistrationRequest()
{
Name = model.Name,
SurName = model.SurName,
UserType = model.UserType == Utilities.UserType.TrainnerUser ? Utilities.UserType.User : model.UserType,
Phone = model.Phone,
Email = string.IsNullOrEmpty(model.Email) ? string.Empty : model.Email,
Password = model.Password,
Image = base64,
About = string.IsNullOrEmpty(model.About) ? string.Empty : model.About,
Accept = false
};
_context.RegistrationRequests.AddAsync(newRequest);
_context.SaveChangesAsync();
if (newRequest.Accept == false)
{
string strMsg = "Your registration request is under review. We will look it as soon as possible. ";
script = "<script language=\"javascript\" type=\"text/javascript\">alert('" + strMsg + "'); window.location='Registration'; </script>";
return(script);
}
else
{
return(script);
}
}
catch (Exception ex)
{
string strMsg = "Something Went Wrong or not all required fileds are filled try again";
script = "<script language=\"javascript\" type=\"text/javascript\">alert('" + strMsg + "'); window.location='Registration'; </script>";
return(script);
}
}