public ActionResult Edit(int id)
{
User user;
using (IUnitOfWork unitOfWork = new TskDataDataContext(DbUtil.ConnectionString))
{
IUserRep userRep = new UserRep(unitOfWork);
user = userRep.FindById(id);
if (user != null)
{
if (Brilliantech.Tsk.Manage.WebApp.Util.CustomMembershipProvider.CanEdit(user.Name))
{
ViewData["Role"] = new SelectList(UserRoleModel.UserRoleList(), "Key", "Name", user.Role);
return(View(user));
}
else
{
TempData["Message"] = "初始管理员，不可以编辑";
return(RedirectToAction("Index"));
}
}
else
{
return(RedirectToAction("Index"));
}
}
}
public HttpResponseMessage SaveUserRole([FromBody] UserRoleModel userrolemodel)
{
string UserRoleID = "-1";
try
{
Mapper.CreateMap <CommunicationApp.Models.UserRoleModel, CommunicationApp.Entity.UserRole>();
CommunicationApp.Entity.UserRole Userrole = Mapper.Map <CommunicationApp.Models.UserRoleModel, CommunicationApp.Entity.UserRole>(userrolemodel);
if (Userrole.UserRoleId <= 0) //new
{
//Insert the Country
_UserRoleservice.InsertUserRole(Userrole); //Save Operation
//End : Insert the Customer
}
else
{
_UserRoleservice.UpdateUserRole(Userrole); //Update Operation
}
UserRoleID = Userrole.UserRoleId.ToString();
return(Request.CreateResponse(HttpStatusCode.OK, CommonCls.CreateMessage("success", UserRoleID), Configuration.Formatters.JsonFormatter));
}
catch (Exception ex)
{
string ErrorMsg = ex.Message.ToString();
ErrorLogging.LogError(ex);
return(Request.CreateResponse(HttpStatusCode.OK, CommonCls.CreateMessage("error", UserRoleID), Configuration.Formatters.JsonFormatter));
}
}
public IActionResult AlterModal(int id)
{
if (id == 0)
{
return(BadRequest(new {
Mensagem = "O id do usuário não foi informado!"
}));
}
using (var user = new UserModel())
{
if (!user.GetById(id, _connection, null))
{
return(BadRequest(new
{
Mensagem = $"Não foi encontrado nenhum usuário com o id '{id}'!"
}));
}
LoadFuncoes();
return(View(new AlterViewModel()
{
Id = user.Id,
Nome = user.Nome,
Email = user.Email,
DataNascimento = user.DataNascimento,
Funcoes = UserRoleModel.GetNormalizedNameRolesByIdUsuario(user.Id, _connection, null)
}));
}
}
public async Task <IActionResult> EditUsersInRole(string roleId)
{
ViewBag.roleId = roleId;
var role = await roleManager.FindByIdAsync(roleId);
if (role == null)
{
ViewBag.ErrorMessage = $"Role with Id = {roleId} cannot be found";
return(View("NotFound"));
}
var model = new List <UserRoleModel>();
foreach (var user in userManager.Users)
{
UserRoleModel userrole = new UserRoleModel();
userrole.UserId = user.Id;
userrole.UserName = user.UserName;
if (await userManager.IsInRoleAsync(user, role.Name))
{
userrole.IsSelected = true;
}
else
{
userrole.IsSelected = false;
}
model.Add(userrole);
}
return(View(model));
}
public bool ValidateModel(UserRoleModel urm, out string mesg)
{
int err_ctr = 0;
StringBuilder sb = new StringBuilder();
mesg = string.Empty;
bool IsOk = true;
if (urm.RoleID == null || urm.RoleID == 0)
{
err_ctr += 1;
sb.Append("Role must be specified");
}
if (urm.EmployeeId == null || urm.EmployeeId == 0)
{
err_ctr += 1;
sb.Append("Employee must be specified");
}
if (err_ctr > 0)
{
IsOk = false;
mesg = sb.ToString();
}
return(IsOk);
}
public async Task <ActionResult> UserRole(string id)
{
var user = await _userManager.FindByIdAsync(id);
var userRoles = await _userManager.GetRolesAsync(user);
var roles = _roleManager.Roles.Where(x => !userRoles.Contains(x.Name));
List <SelectListItem> rolesList = new List <SelectListItem>();
if (roles.Count() > 0)
{
rolesList = roles.Select(x => new SelectListItem {
Text = x.Name, Value = x.Name
}).ToList();
rolesList.Insert(0, new SelectListItem {
Text = "Choose a role", Value = "0", Selected = true, Disabled = true
});
}
UserRoleModel userRoleModel = new UserRoleModel
{
Roles = rolesList,
UserRoles = userRoles.ToList(),
User = user
};
return(View(userRoleModel));
}
private static void SeedUsers(DatabaseContext context)
{
if (context.Users.Find(1L) != null)
{
return;
}
var hash = new Hash();
var userModel = new UserModel
{
Name = "Administrator",
Surname = "Administrator",
Email = "*****@*****.**",
Login = hash.Generate("admin"),
Password = hash.Generate("admin"),
Status = Status.Active
};
var userRoleModel = new UserRoleModel {
UserId = 1, Role = Roles.Admin
};
context.Users.Add(userModel);
context.UsersRoles.Add(userRoleModel);
}
public async Task <IActionResult> EditUsersInRole(string roleId)
{
ViewBag.roleId = roleId;
var role = await _roleManager.FindByIdAsync(roleId);
if (role == null)
{
throw new ArgumentNullException(nameof(roleId));
}
var model = new List <UserRoleModel>();
foreach (var user in _userManager.Users)
{
var userRoleModel = new UserRoleModel()
{
UserId = user.Id,
UserName = user.UserName
};
if (await _userManager.IsInRoleAsync(user, role.Name))
{
userRoleModel.IsSelected = true;
}
else
{
userRoleModel.IsSelected = false;
}
model.Add(userRoleModel);
}
return(View(model));
}
/// <summary>
/// 添加角色记录
/// </summary>
/// <returns>DataTable</returns>
public static bool InsertUserRole(UserRoleModel model, string loginUserID)
{
//SQL拼写
StringBuilder sql = new StringBuilder();
sql.AppendLine("INSERT INTO dbo.UserRole");
sql.AppendLine(" (CompanyCD ");
sql.AppendLine(" ,UserID ");
sql.AppendLine(" ,RoleID ");
sql.AppendLine(" ,ModifiedDate ");
sql.AppendLine(" ,ModifiedUserID) ");
sql.AppendLine("VALUES ");
sql.AppendLine(" (@CompanyCD ");
sql.AppendLine(" ,@UserID ");
sql.AppendLine(" ,@RoleID ");
sql.AppendLine(" ,getdate() ");
sql.AppendLine(" ,'"+ loginUserID + "') ");
//设置参数
SqlParameter[] param = new SqlParameter[3];
param[0] = SqlHelper.GetParameter("@CompanyCD", model.CompanyCD);
param[1] = SqlHelper.GetParameter("@UserID", model.UserID);
param[2] = SqlHelper.GetParameter("@RoleID", model.RoleID);
SqlHelper.ExecuteTransSql(sql.ToString(), param);
return(SqlHelper.Result.OprateCount > 0 ? true : false);
}
public virtual IActionResult Create(UserRoleModel model, bool continueEditing)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageUsers))
{
return(AccessDeniedView());
}
if (ModelState.IsValid)
{
var userRole = model.ToEntity <UserRole>();
_userService.InsertUserRole(userRole);
//activity log
//_userActivityService.InsertActivity("AddNewUserRole",
// string.Format("ActivityLog.AddNewUserRole {0}", userRole.Name), userRole);
SuccessNotification("Admin.Users.UserRoles.Added");
return(continueEditing ? RedirectToAction("Edit", new { id = userRole.Id }) : RedirectToAction("List"));
}
//prepare model
model = _userRoleModelFactory.PrepareUserRoleModel(model, null, true);
//if we got this far, something failed, redisplay form
return(View(model));
}
public async Task <IEnumerable <UserRoleModel> > GetUserRoleAsync()
{
var query = await(from userRole in _db.UserRoles
join users in _db.Users
on userRole.UserId equals users.Id
join roles in _db.Roles
on userRole.RoleId equals roles.Id
select new
{
userRole.UserId,
users.UserName,
userRole.RoleId,
roles.Name
}).ToListAsync();
List <UserRoleModel> userRoles = new List <UserRoleModel>();
if (query.Count > 0)
{
for (var i = 0; i < query.Count; i++)
{
var model = new UserRoleModel
{
UserId = query[i].UserId,
UserName = query[i].UserName,
RoleId = query[i].RoleId,
RoleName = query[i].Name
};
userRoles.Add(model);
}
}
return(userRoles);
}
public async Task <IActionResult> EditUsersInRole(string roleId)
{
ViewBag.roleId = roleId;
if (roleId == null)
{
return(RedirectToAction("EditRole", new { Id = roleId }));
}
var role = await _roleManager.FindByIdAsync(roleId);
if (role == null)
{
ViewBag.ErrorMessage = $"Role with Id= {roleId} cannot be found";
return(View());
}
var model = new List <UserRoleModel>();
foreach (var user in _userManager.Users)
{
var userRoleModel = new UserRoleModel {
UserId = user.Id, UserName = user.UserName
};
if (await _userManager.IsInRoleAsync(user, role.Name))
{
userRoleModel.IsSelected = true;
}
else
{
userRoleModel.IsSelected = false;
}
model.Add(userRoleModel);
}
return(View(model));
}
public virtual ActionResult UserRoles(FormCollection userRoles)
{
var roleModel = Session["Roles"] as UserRolesModel;
var userName = Session["UserName"].ToString();
if (roleModel != null)
{
for (var i = 0; i < roleModel.UserRoles.Count(); i++)
{
var model = new UserRoleModel {
RoleId = roleModel.UserRoles[i].RoleId, RoleName = roleModel.UserRoles[i].RoleName
};
model.Selected = userRoles.GetValue(string.Format("[{0}].Selected", model.RoleId)).AttemptedValue.Contains("true");
if (model.Selected != roleModel.UserRoles[i].Selected)
{
if (model.Selected)
{
new Role().AddUserToRole(model.RoleId, userName);
}
else
{
new Role().RemoveRole(model.RoleName, userName);
}
}
}
}
return(Json(new { success = true }));
}
public ActionResult UserRole(UserRoleModel model)
{
var result = new Result();
try
{
if (string.IsNullOrEmpty(model.UserIds))
{
result.Msg = "UserId不能为空";
return(Json(result));
}
if (string.IsNullOrEmpty(model.RoleIds))
{
result.Msg = "RoleId不能为空";
return(Json(result));
}
var isScussce = new UserRoleBLL().Create(model);
if (isScussce)
{
result.Msg = "设置成功！";
result.Success = true;
}
else
{
result.Msg = "设置失败！";
}
return(Json(result));
}
catch (Exception ex)
{
result.Msg = string.Format("设置失败！{0}", ex.Message);
return(Json(result));
}
}
public async Task <ActionResult> Index([Bind(Include = "UserId,UserName,RoleId,RoleName")] UserRoleModel userRoleModel)
{
if (ModelState.IsValid)
{
userRoleModel.RoleName = db.AspNetRoles.FirstOrDefault(x => x.Id == userRoleModel.RoleId).Name;
switch (userRoleModel.RoleName)
{
case "Admin":
await UserManager.AddToRoleAsync(userRoleModel.UserId, "Admin");
//await UserManager.AddToRoleAsync(userRoleModel.UserId, "Manager");
await UserManager.AddToRoleAsync(userRoleModel.UserId, "User");
break;
case "Manager":
await UserManager.AddToRoleAsync(userRoleModel.UserId, "Manager");
//await UserManager.AddToRoleAsync(userRoleModel.UserId, "User");
break;
case "User":
await UserManager.AddToRoleAsync(userRoleModel.UserId, "User");
break;
}
}
//ViewBag.UserId = new SelectList(db.AspNetUsers, "Id", "Hometown", userRoleModel.UserId);
//return View(userRoleModel);
return(RedirectToAction("Index"));
}
public JsonResult SetRole(UserRoleModel model)
{
try
{
var user = db.AspNetUsers.Find(model.UserId);
if (user != null)
{
if (!user.AspNetRoles.Any(r => r.Id == model.RoleId) &&
model.IsChecked)
{
var roleToAdd = db.AspNetRoles.Find(model.RoleId);
user.AspNetRoles.Add(roleToAdd);
}
else if (user.AspNetRoles.Any(r => r.Id == model.RoleId) &&
!model.IsChecked)
{
user.AspNetRoles.Remove(user
.AspNetRoles
.First(r => r.Id == model.RoleId));
}
db.SaveChanges();
return(Json(new { Result = true }, JsonRequestBehavior.AllowGet));
}
return(Json(new { Result = false, Message = "the user doesn't exist" }, JsonRequestBehavior.AllowGet));
}
catch (Exception ex)
{
return(Json(new { Result = false, Message = ex.Message }, JsonRequestBehavior.AllowGet));
}
}
public async Task <IActionResult> EditUsersInRole(string roleId)
{
ViewBag.RoleID = roleId;
var role = await roleManager.FindByIdAsync(roleId);
if (role == null)
{
ViewBag.ErrorMessage = $"Role with ID : {roleId} cannot be found";
return(View("NotFound"));
}
var model = new List <UserRoleModel>();
foreach (var item in userManager.Users)
{
var userRoleModel = new UserRoleModel
{
ID = item.Id,
Username = item.UserName
};
if (await userManager.IsInRoleAsync(item, role.Name))
{
userRoleModel.IsSelected = true;
}
else
{
userRoleModel.IsSelected = false;
}
model.Add(userRoleModel);
}
return(View(model));
}
public async Task <ActionResult> Delete(UserRoleModel model)
{
if (!_permissionService.Authorize(PermissionProvider.ManageUser))
{
return(AccessDeniedView());
}
if (ModelState.IsValid)
{
if (model.Id <= 0)
{
return(Json(new { status = "false", Content = "Identity of User Role is invalid." }));
}
var userRole = await _userRoleService.GetByIdAsync(model.Id);
if (userRole == null)
{
return(Json(new { status = "false", Content = "Can not found User Role." }));
}
try
{
await _userRoleService.DeleteAsync(userRole);
}
catch (Exception ex)
{
return(Json(new { status = "false", Content = ex.Message }));
}
return(Json(new { status = "success" }));
}
return(Json(new { Data = new[] { model } }));
}
public ActionResult AdminList(int pageSize = 10, int pageNumber = 1)
{
pageSize = WorkContext.SiteConfig.pageSize;
string condition = "AdminGroupID > 0";
string sort = "UserID desc";
PageModel pageModel = new PageModel(pageSize, pageNumber, Users.AdminGetUserCount(condition));
UsersListModel model = new UsersListModel()
{
DataList = Users.AdminGetUserList(pageModel.PageSize, pageModel.PageNumber, condition, sort),
PageModel = pageModel
};
UserRoleModel userRoleModel = new UserRoleModel();
userRoleModel.UserRoleList = UserRoles.GetUserRoleList();
List <UserRoleInfo> resultList = new List <UserRoleInfo>();
resultList = userRoleModel.UserRoleList.ToList();
TempData["userModelList"] = resultList;
SiteUtils.SetAdminRefererCookie(string.Format("{0}?pageNumber={1}&pageSize={2}",
Url.Action("AdminList"),
pageModel.PageNumber,
pageModel.PageSize));
return(View(model));
}
public async Task <JsonResult> SaveUserRole([FromBody] UserRoleModel model)
{
try
{
var userrole = new apec_khktdocs_userrole
{
id = model.id,
username = model.username,
isadmin = model.isadmin,
isapprove = model.isapprove,
isaccess = model.isaccess,
isdelete = model.isdelete,
issuperadmin = 0
};
var result = await _userRoleService.SaveUserRole(userrole);
if (result != -1)
{
return(Json(new { status = "success", message = "success" }));
}
return(Json(new { status = "fail", message = "Không thêm mới cho user đã có quyền" }));
}
catch (System.Exception)
{
return(Json(new { status = "fail", message = "fail" }));
}
}
public IHttpActionResult GetAllUserRole()
{
int companyId = Global.GetCompanyIdFromToken();
UserRoleModel model = new UserRoleModel();
return(Ok(model.GetAllByCompanyId(companyId)));
}
private void SaveUserAdministrador()
{
if (User.Find(1L) != null)
{
return;
}
var _hash = new Hash();
var userModel = new UserModel
{
Name = "Administrator",
Surname = "Administrator",
Email = "*****@*****.**",
Login = _hash.Generate("admin"),
Password = _hash.Generate("admin"),
Status = Status.Active
};
var userRoleModel = new UserRoleModel {
UserId = 1, Role = Role.Admin
};
Set <UserModel>().Add(userModel);
Set <UserRoleModel>().Add(userRoleModel);
}
public IHttpActionResult CreateUserRole([FromBody] UserRoleModel.Format_Create dataModel)
{
string logForm = "Form : " + JsonConvert.SerializeObject(dataModel);
string logAPI = "[Post] " + Request.RequestUri.ToString();
if (!ModelState.IsValid || dataModel == null)
{
Global._appLogger.Warn(logAPI + " || Input Parameter not expected || " + logForm);
return(Content(HttpStatusCode.BadRequest, HttpResponseFormat.InvaildData()));
}
try
{
int companyId = Global.GetCompanyIdFromToken();
UserRoleModel model = new UserRoleModel();
model.Create(companyId, dataModel);
return(Content(HttpStatusCode.OK, HttpResponseFormat.Success()));
}
catch (CDSException cdsEx)
{
return(Content(HttpStatusCode.BadRequest, CDSException.GetCDSErrorMessageByCode(cdsEx.ErrorId)));
}
catch (Exception ex)
{
StringBuilder logMessage = LogHelper.BuildExceptionMessage(ex);
logMessage.AppendLine(logForm);
Global._appLogger.Error(logAPI + logMessage);
return(Content(HttpStatusCode.InternalServerError, ex));
}
}
public String Index(UserRoleModel model)
{
UserRoleModelRepo repo = new UserRoleModelRepo(ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString);
repo.Save(model.UserId, model.RoleId);
return("Assign successfully");
}
public ActionResult Edit(UserRoleModel model)
{
var result = new JsonModel();
var opType = OperationType.Insert;
UserRole role = null;
if (model.Id > 0)
{
role = UserRoleRepository.Get(model.Id);
if (role == null)
{
result.msg = $"找不到id为{0}的角色";
return(Json(result));
}
opType = OperationType.Update;
}
else
{
role = new UserRole();
}
Mapper.Map(model, role);
UserRoleSvc.SaveList(role, model.MenuIds);
LogRepository.Insert(TableSource.UserRole, opType, role.Id);
result.code = JsonModelCode.Succ;
ShowSuccMsg("保存成功！");
return(Json(result));
}
public ActionResult AddToRole(Guid id, int?roleRef)
{
var user = _Storage.GetUser(u => u.Id == id);
if (roleRef == null)
{
var userList =
_Storage.GetRolesAvailableToUser(user).Select(
r =>
new SelectListItem
{
Text = Localization.getMessage(r.ToString()),
Value = ((int)r).ToString(),
Selected = false
});
var userRole = new UserRoleModel {
RoleList = userList
};
ModelState.AddModelError("RoleRef", "Please select role from list");
return(View(userRole));
}
var role = UserRoles.GetRole(roleRef.Value);
_Storage.AddUserToRole(role, user);
return(RedirectToAction("Details", new { Id = id }));
}
public async Task <bool> CheckIfCurrentUserRoleIsCourier(int userID)
{
string link = ServerLink + "GetCurrentUserRole/" + userID;
var ur = await _client.GetAsync(link);
if (ur.IsSuccessStatusCode)
{
var responseString = await ur.Content.ReadAsStringAsync();
UserRoleModel userRole = JsonConvert.DeserializeObject <UserRoleModel>(responseString);
if (userRole.RoleID == 4)
{
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
public async Task <IResult <UserRolesResponse> > GetRolesAsync(string userId)
{
var viewModel = new List <UserRoleModel>();
var user = await _userManager.FindByIdAsync(userId);
foreach (var role in _roleManager.Roles)
{
var userRolesViewModel = new UserRoleModel
{
RoleName = role.Name
};
if (await _userManager.IsInRoleAsync(user, role.Name))
{
userRolesViewModel.Selected = true;
}
else
{
userRolesViewModel.Selected = false;
}
viewModel.Add(userRolesViewModel);
}
var result = new UserRolesResponse {
UserRoles = viewModel
};
return(Result <UserRolesResponse> .Success(result));
}
public IActionResult AlterModal(AlterViewModel model)
{
if (!ModelState.IsValid)
{
LoadFuncoes();
return(View(model));
}
using (var user = new UserModel())
{
if (!user.GetById(model.Id, _connection, null))
{
LoadFuncoes();
return(View(model));
}
user.Nome = model.Nome;
user.Email = model.Email;
user.DataNascimento = (DateTime)model.DataNascimento;
user.Salvar(_connection, null);
// Remover funções
foreach (var funcao in UserRoleModel.GetNormalizedNameRolesByIdUsuario(user.Id, _connection, null))
{
if (model.Funcoes.Where(a => a.Equals(funcao)).Count() == 0)
{
using (var role = new RoleModel())
{
if (!role.GetByNomeNormalized(funcao, _connection, null))
{
continue;
}
using (var userRole = new UserRoleModel())
{
if (!userRole.GetByIdUsuarioAndIdRole(user.Id, role.Id, _connection, null))
{
continue;
}
userRole.Remover(_connection, null);
}
}
}
}
// Adicionar funções
foreach (var funcao in model.Funcoes)
{
if (!UserRoleModel.UserInRole(user.Id, funcao, _connection, null))
{
Task <IdentityResult> result = _userManager.AddToRoleAsync(user, funcao);
result.Wait();
}
}
return(Ok());
}
}
public IActionResult Save(UserRoleModel role)
{
try
{
if (string.IsNullOrWhiteSpace(role.Name) || role.AccessLevel == 0)
{
return(Json(new ReturnDefault(false, "You have required fields not filled in")));
}
string successMessage = role.Id == 0 ? "Role added" : "edited role";
string errorMessage = string.Empty;
var result = _application.Save(role, ref errorMessage);
if (!string.IsNullOrWhiteSpace(errorMessage))
{
return(Json(new ReturnDefault(false, errorMessage)));
}
return(Json(new ReturnDefault(true, successMessage, result)));
}
catch (Exception)
{
return(Json(new ReturnDefault(false, "An error has occurred, Please contact the support team")));
}
}
public async Task<HttpResponseMessage> Post(UserModel entity,
UserRoleModel entityUserRole = null)
{
entity.ID = Guid.NewGuid().ToString("N");
try
{
if (entityUserRole != null)
{
entityUserRole.RoleID = entityUserRole.RoleID;
entityUserRole.UserID = entity.ID; // je li to u redu tako? (slozeni primarni kljuc)
}
var result = await Service.InsertAsync(Mapper.Map<IUser>(entity),
Mapper.Map<IUserRole>(entityUserRole));
if (result == 1)
{
return Request.CreateResponse(HttpStatusCode.OK, entity);
}
else
{
return Request.CreateResponse(HttpStatusCode.BadRequest, "POST unsuccessful.");
}
}
catch (Exception e)
{
return Request.CreateResponse(HttpStatusCode.BadRequest, e.ToString());
}
}
public string SaveUserRole(string userId, string roleIds)
{
if (string.IsNullOrWhiteSpace(userId) || string.IsNullOrWhiteSpace(roleIds))
{
return "0";
}
UserRoleModel.Delete("where UserID = @0", userId);
string[] roleList = roleIds.Split(',');
foreach (string role in roleList)
{
UserRoleModel model = new UserRoleModel();
model.Userid = userId.ToInt();
model.Roleid = role.ToInt();
model.CreateMan = SysConfig.CurrentUser.Id;
model.CreateTime = DateTime.Now;
model.Insert();
}
//记录操作日志
CommonMethod.Log(SysConfig.CurrentUser.Id, "Insert", "Sys_User_Role",
string.Format("给主键为{0}的用户绑定主键为{1}的角色", userId, roleIds));
return "1";
}
public async Task<HttpResponseMessage> Put(string ID, UserModel entity,
UserRoleModel entityUserRole = null)
{
try
{
if (ID != entity.ID)
{
return Request.CreateResponse(HttpStatusCode.BadRequest, "IDs do not match.");
}
if (entityUserRole != null)
{
entityUserRole.UserID = ID;
}
var result = await Service.UpdateAsync(Mapper.Map<IUser>(entity),
Mapper.Map<IUserRole>(entityUserRole));
if (result == 1)
{
return Request.CreateResponse(HttpStatusCode.OK, entity);
}
else
{
return Request.CreateResponse(HttpStatusCode.InternalServerError, "PUT unsuccessful.");
}
}
catch (Exception e)
{
return Request.CreateResponse(HttpStatusCode.BadRequest, e.ToString()); ;
}
}
