// POST odata/User
public virtual async Task<IHttpActionResult> Post(User user)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
try
{
await MainUnitOfWork.InsertAsync(user);
}
catch (DbUpdateException)
{
if (MainUnitOfWork.Exists(user.Id))
{
return Conflict();
}
else
{
throw;
}
}
return Created(user);
}
public object GetUserByUserName(string userName)
{
//logger.Debug("Start");
User user = new User();
try
{
if (String.IsNullOrEmpty(userName))
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
else
{
user = _ldapService.GetUserByUserName(userName);
}
}
catch (Exception e)
{
logger.ErrorException("Exception", e);
}
return user;
}
/// <summary>
/// Builds new Ship from preset, user, and cellTypes
/// </summary>
/// <param name="owner">User, who owns the Ship</param>
/// <param name="preset">Ship preset</param>
/// <param name="cellTypes">cellTypes[i] - type of room with id = i</param>
/// <returns>Built Ship</returns>
public Ship BuildShip(User owner, ShipPreset preset, IEnumerable<int> cellTypes)
{
Ship ship = new Ship(owner, preset.RoomIds.GetLength(1), preset.RoomIds.GetLength(0));
ship.preset = preset;
currentWeaponId = 0;
assignedWeaponIds = new Dictionary<int, int>();
for (int i = 0; i < ship.cells.Length; i++)
{
for (int j = 0; j < ship.cells[i].Length; j++)
{
int roomId = preset.RoomIds[i, j];
ship.cells[i][j] = buildCell(ship, cellTypes.ToList()[roomId], roomId);
if (currentWeaponId >= preset.weapons.Length) currentWeaponId = 0;
}
}
assignesStatuses = new Dictionary<int, CellStatus>();
InitCellStatuses(ship, preset);
if (preset.afterShipBuilt != null)
preset.afterShipBuilt.Invoke(ship);
return ship;
}
// PUT odata/User(5)
public virtual async Task<IHttpActionResult> Put([FromODataUri] int key, User user)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
if (key != user.Id)
{
return BadRequest();
}
try
{
await MainUnitOfWork.UpdateAsync(user);
}
catch (DbUpdateConcurrencyException)
{
if (!MainUnitOfWork.Exists(key))
{
return NotFound();
}
else
{
return Conflict();
}
}
return Ok(user);
}
public IHttpActionResult PutUser(int id, User user)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
if (id != user.UserID)
{
return BadRequest();
}
db.Entry(user).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!UserExists(id))
{
return NotFound();
}
else
{
throw;
}
}
return StatusCode(HttpStatusCode.NoContent);
}
public IHttpActionResult GetEvent(int id)
{
Event @event = db.Events.Find(id);
if (@event == null)
{
return NotFound();
}
List<User> custUserList = new List<User>();
foreach (User myUser in @event.Users)
{
User custUser = new User();
custUser.address = myUser.address;
custUser.credit = myUser.credit;
custUser.dob = myUser.dob;
custUser.email = myUser.email;
custUser.emgcontact = myUser.emgcontact;
custUser.emgrelationship = myUser.emgrelationship;
custUser.Events = new List<Event>();
custUser.fbtoken = myUser.fbtoken;
custUser.gender = myUser.gender;
custUser.geocode = myUser.geocode;
custUser.id = myUser.id;
custUser.ImgUrl = myUser.ImgUrl;
custUser.name = myUser.name;
custUser.phone = myUser.phone;
custUser.ubertoken = myUser.ubertoken;
custUserList.Add(custUser);
}
@event.Users = custUserList;
return Ok(@event);
}
public async Task<IHttpActionResult> CreateUser(UserCreationDto dto)
{
if (UserNameExists(dto.UserName))
{
return BadRequest("已存在此登录名");
}
//create user
var user = new User
{
UserName = dto.UserName,
DisplayName = dto.DisplayName,
Class = dto.ClassNumber,
Grade = dto.Grade,
Roles = new HashSet<UserRole>()
};
var result = await _userManager.CreateAsync(user, dto.Password);
if (!result.Succeeded)
{
return BadRequest(string.Join(" ", result.Errors));
}
var userId = (await _userManager.FindByNameAsync(user.UserName)).Id;
//add to role
dto.Roles.ToList().ForEach(rs => { _userManager.AddToRole(userId, rs); });
return StatusCode(HttpStatusCode.Accepted);
}
public IHttpActionResult FindUsers(string q = null, bool rq = false)
{
IEnumerable<User> Users = null;
if (q == null)
{
Users = Lookup.Data.AllUsers();
}
else
{
Users = Lookup.Data.FindUsers(q);
}
if (rq)
{
var User = new User();
User.Name = q;
User.Title = "Click here if the user is not listed below.";
User.Office = string.Empty;
User.PhotoUrl = Properties.Settings.Default.NoPhotoImageUrl;
Users = Users.Concat(new User[] { User });
}
return Ok(Users);
}
// PUT api/Users/5
public HttpResponseMessage PutUser(int id, User user)
{
if (!ModelState.IsValid)
{
return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
if (id != user.Id)
{
return Request.CreateResponse(HttpStatusCode.BadRequest);
}
db.Entry(user).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException ex)
{
return Request.CreateErrorResponse(HttpStatusCode.NotFound, ex);
}
return Request.CreateResponse(HttpStatusCode.OK);
}
// POST api/User
public HttpResponseMessage PostUser(User user)
{
if (ModelState.IsValid)
{
if (!db.Users.Any())
{
user.UserID = 0;
}
else
{
user.UserID = db.Users.Max(record => record.UserID) + 1;
}
db.Users.Add(user);
db.SaveChanges();
db.Configuration.ProxyCreationEnabled = false;
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.Created, user);
response.Headers.Location = new Uri(Url.Link("DefaultApi", new { id = user.UserID }));
return response;
}
else
{
return Request.CreateResponse(HttpStatusCode.BadRequest);
}
}
public static TaskListModel GetTasksListByDate(DateTime date, User currentUser)
{
BYEntities db = new BYEntities();
List<Task> tempUncTasks = db.Tasks.Where(x => db.Calendars.Any(
y => EntityFunctions.TruncateTime(y.Date) == date
&& x.Id == y.TaskId
&& y.UserId == currentUser.Id
&& y.TaskCompleted == false)).ToList();
List<TasksModel> uncompletedTasks = new List<TasksModel>();
foreach (Task tsk in tempUncTasks)
{
uncompletedTasks.Add(new TasksModel(tsk));
}
List<Task> tempCompTasks = db.Tasks.Where(x => db.Calendars.Any(
y => EntityFunctions.TruncateTime(y.Date) == date
&& x.Id == y.TaskId
&& y.UserId == currentUser.Id
&& y.TaskCompleted == true)).ToList();
List<TasksModel> completedTasks = new List<TasksModel>();
foreach (Task tsk in tempCompTasks)
{
completedTasks.Add(new TasksModel(tsk));
}
return new TaskListModel(completedTasks, uncompletedTasks);
}
// PUT odata/User(5)
public async Task<IHttpActionResult> Put([FromODataUri] string key, User user)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
if (key != user.Id)
{
return BadRequest();
}
db.Entry(user).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UserExists(key))
{
return NotFound();
}
else
{
throw;
}
}
return Updated(user);
}
public async Task<HttpResponseMessage> RegisterUser(RegisterBindingModel userData)
{
if (!ModelState.IsValid)
{
return await this.BadRequest(this.ModelState).ExecuteAsync(new CancellationToken());
}
var user = new User
{
UserName = userData.Username,
Email = userData.Email,
Name = userData.Name
};
var identityResult = await this.UserManager.CreateAsync(user, userData.Password);
if (!identityResult.Succeeded)
{
return await this.GetErrorResult(identityResult).ExecuteAsync(new CancellationToken());
}
var loginResult = this.LoginUser(new LoginBindingModel()
{
Username = userData.Username,
Password = userData.Password
});
return await loginResult;
}
public int Post(User user)
{
if (user == null)
return 0;
if (user.Password == null)
return 0;
return service.SignInUser(user.Email, user.Password.Password);
}
public void UpdateUser(User userUpdated)
{
//TODO - Deal with null
var user = GetUser(userUpdated.Id);
user.Username = userUpdated.Username;
user.FirstName = userUpdated.FirstName;
user.LastName = userUpdated.LastName;
_ctx.SaveChanges();
}
protected void ExtraModelToEntity(User entity, UserModel model, ActionTypes actionType)
{
if (actionType == ActionTypes.Add)
{
entity.Password = StringHelper.GetMD5Hash(model.password);
entity.Key = StringHelper.GetMD5Hash(String.Format("{0}_{1}", model.login, model.password));
}
}
// PUT odata/User(5)
public override async Task<IHttpActionResult> Put([FromODataUri] int key, User user)
{
var currentUser = await GetCurrentUserAsync();
var isAdmin = this.GetCurrentUserIsAdmin();
if (user.Id != currentUser.Id && !isAdmin)
return Unauthorized();
return await base.Put(key, user);
}
public IList<Pet> GetAllPet(User user)
{
using (var session = NHibernateHelper.OpenSession())
{
var pets = session.CreateQuery("from Pet where user_id = :id")
.SetParameter("id", user.Id).List<Pet>();
return pets;
}
}
public IHttpActionResult PostUser(User user)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
_userRepo.Post(user);
return CreatedAtRoute("DefaultApi", new { id = user.Id }, user);
}
// POST: odata/User
public async Task<IHttpActionResult> Post(User user)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
db.Users.Add(user);
await db.SaveChangesAsync();
return Created(user);
}
public IHttpActionResult PostUser(User user)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
db.Users.Add(user);
db.SaveChanges();
return CreatedAtRoute("DefaultApi", new { id = user.UserID }, user);
}
public async Task<IHttpActionResult> PostUser(User user)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
db.Users.Add(user);
await db.SaveChangesAsync();
return CreatedAtRoute("DefaultApi", new { id = user.UserId }, user);
}
public IHttpActionResult UpdateUser(int id, User user)
{
var userToUpdate = this.Data.Users.Get(id);
if (userToUpdate == null)
{
return BadRequest(string.Format("Failed to update user. No user with id {0} found.", id));
}
userToUpdate.Login = user.Login;
this.Data.SaveChanges();
return Ok();
}
protected override void Validate(UserModel model, User entity, ActionTypes actionType)
{
if (!string.Equals(model.login, entity.Login, System.StringComparison.InvariantCultureIgnoreCase))
{
if (Manager.GetByLogin(model.login) != null)
ModelState.AddModelError("model.login", "login-unique");
}
if (actionType == ActionTypes.Add)
{
if (string.IsNullOrEmpty(model.password))
ModelState.AddModelError("model.password", "required");
}
}
private string GenerateMailBody(User user)
{
string overdueTask = string.Empty;
string todaysTask = string.Empty;
string dueTommorrowTask = string.Empty;
string futureTask = string.Empty;
string messageBody = string.Empty;
IQueryable<Task> taskList = unitofWork.TaskRepository.GetTasksByUser(user);
messageBody = "<b>Dear " + user.FirstName + "</b>,<br>" + "<b>You have the following tasks:</b><br>";
foreach (Task task in taskList)
{
if (task.EndDate < DateTime.Today) // overdue task
{
overdueTask += "<li>" + task.Title + "</li>";
}
else if (task.StartDate == DateTime.Today) // todays task
{
todaysTask += "<li>" + task.Title + "</li>";
}
else if (task.EndDate == DateTime.Today.AddDays(1)) //due tomorrow task
{
dueTommorrowTask += "<li>" + task.Title + "</li>";
}
else if (task.StartDate > DateTime.Today) //Future task
{
futureTask += "<li>" + task.Title + "</li>";
}
}
if (overdueTask != string.Empty)
{
messageBody += "<b>Overdue tasks:</b> <br>" + overdueTask;
}
if (todaysTask != string.Empty)
{
messageBody += "<b>Today's tasks:</b> <br>" + todaysTask;
}
if (dueTommorrowTask != string.Empty)
{
messageBody += "<b>Due Tommorrow's tasks:</b> <br>" + dueTommorrowTask;
}
if (futureTask != string.Empty)
{
messageBody += "<b>Future tasks:</b> <br>" + futureTask;
}
return messageBody;
}
// POST api/Users
public HttpResponseMessage PostUser(User user)
{
if (ModelState.IsValid)
{
db.Users.Add(user);
db.SaveChanges();
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.Created, user);
response.Headers.Location = new Uri(Url.Link("DefaultApi", new { id = user.Id }));
return response;
}
else
{
return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
}
public User Post(User user)
{
User oldUser = Get(user.Email);
if(oldUser!=null)
throw new HttpResponseException(System.Net.HttpStatusCode.Conflict);
if(user.Memberships==null)
user.Memberships = new GroupMembership[0];
service.SaveUser(user);
log.Log(String.Format(SharedStringsLog.USER_CREATION_0, user.Email));
return user;
}
public UserCredentials Create([FromBody] UserCredentials createUser)
{
UserCredentials user = null;
User usr = null;
//if (dbContext.Users.Count() > 0)
//{
usr = dbContext.Users.FirstOrDefault(i => i.Username.Equals(createUser.UserName));
if (usr != null)
throw new HttpResponseException
(new HttpResponseMessage
{
ReasonPhrase = "User Already Exists",
StatusCode = HttpStatusCode.InternalServerError
});
//}
//if (usr == null)
//{
var userInsert = new User
{
Username = createUser.UserName,
Password = createUser.Password
};
dbContext.Users.AddObject(userInsert);
var userId = dbContext.SaveChanges();
var customerInsert = new Customer
{
CustomerName = createUser.CustomerName,
Phone = createUser.Phone,
Email = createUser.Email,
Address = createUser.CustomerAddress,
UserId = userInsert.UserId
};
dbContext.Customers.AddObject(customerInsert);
dbContext.SaveChanges();
createUser.CustomerId = customerInsert.CustomerId;
createUser.UserId = userInsert.UserId;
user = createUser;
return user;
// }
//return user;
}
/// <summary>
/// Add User
/// </summary>
private User AddUser(User user, RegisterViewModel model, out string error)
{
error = string.Empty;
var result = UserManager.Create(user, model.ConfirmPassword);
if (result.Succeeded)
{
var addUserToRoleResult = UserManager.AddToRole(user.Id, model.SelectedRole);
if (!addUserToRoleResult.Succeeded)
{
throw new InvalidOperationException(string.Format("Failed to add user to role {0}",
model.SelectedRole));
}
return user;
}
error = result.Errors.FirstOrDefault();
return null;
}
public IHttpActionResult AddUser(User user)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
if (user == null)
{
return BadRequest("You must provide an entry of type 'User', 'NULL' provided.");
}
this.Data.Users.Add(user);
this.Data.SaveChanges();
var addedUserId = this.Data.Users.GetAll().FirstOrDefault(u => u.Login == user.Login);
return Ok(addedUserId);
}
