public List <RolesBusinessModel> GetAllRole()
{
List <RolesBusinessModel> usermodel = new List <RolesBusinessModel>();
List <Role> userRoles = new List <Role>();
try
{
userRoles = applicationLevelDataBaseOps.GetAllRoles();
foreach (Role item in userRoles)
{
RolesBusinessModel newRole = new RolesBusinessModel
{
RoleID = item.RoleID,
RoleName = item.RoleName
};
usermodel.Add(newRole);
}
}
catch (Exception ex)
{
usermodel = new List <RolesBusinessModel>();
ExceptionTracker.SendErrorToText(ex);
}
return(usermodel);
}
public EventDetailBusinessModel GetEventDetailById(int id)
{
EventDetail eventEntity = new EventDetail();
EventDetailBusinessModel eventItem;
try
{
eventEntity = applicationLevelDataBaseOps.GetEventDetailById(id);
eventItem = new EventDetailBusinessModel
{
EventName = eventEntity.EventName,
EventDate = eventEntity.EventDate,
EventDescription = eventEntity.EventDescription,
EventDetailID = eventEntity.EventDetailID,
EventType = eventEntity.EventType,
CollageID = eventEntity.CollageID
};
}
catch (Exception ex)
{
eventItem = new EventDetailBusinessModel();
ExceptionTracker.SendErrorToText(ex);
}
return(eventItem);
}
public string Attack(string[] args)
{
var attackerName = args[0];
var receiverName = args[1];
var attackerCharacter = party.FirstOrDefault(c => c.Name == attackerName);
ExceptionTracker.DoesCharacterExist(attackerCharacter, attackerName);
var receiverCharacter = party.FirstOrDefault(c => c.Name == receiverName);
ExceptionTracker.DoesCharacterExist(receiverCharacter, receiverName);
ExceptionTracker.AttackableCharacter(attackerCharacter);
((Warrior)attackerCharacter).Attack(receiverCharacter);
var output = $"{attackerName} attacks {receiverName} for {attackerCharacter.AbilityPoints} hit points!" +
$" {receiverName} has {receiverCharacter.Health}/{receiverCharacter.BaseHealth} HP " +
$"and {receiverCharacter.Armor}/{receiverCharacter.BaseArmor} AP left!";
if (!receiverCharacter.IsAlive)
{
output += $"\n{receiverCharacter.Name} is dead!";
}
return(output);
}
public void CreaeUser(UserBusinessModel userDetail)
{
User UserDetails = applicationLevelDataBaseOps.GetUserDetailByUserName(userDetail.UserName);
if (UserDetails != null)
{
try
{
User user = new User
{
FirstName = userDetail.FirstName,
LastName = userDetail.LastName,
Password = ApplicationLEvelBusinessOperation.Encrypt(userDetail.Password.Trim()),
UserName = userDetail.UserName,
CollageID = userDetail.CollageID,
CreateDate = DateTime.Now,
MdifiedDate = DateTime.Now
};
adminDataBaseOperation.CreaeUser(user);
}
catch (Exception ex)
{
ExceptionTracker.SendErrorToText(ex);
}
}
}
public List <EventRegistrationBusinessModel> UserEventRegistration(int id)
{
List <EventRegistrationBusinessModel> EventRegistrationList = new List <EventRegistrationBusinessModel>();
List <EventRegistration> EventRegistrationListEntity = new List <EventRegistration>();
try
{
EventRegistrationListEntity = teacherBaseOperation.ListofEventRegistration(id);
foreach (EventRegistration item in EventRegistrationListEntity)
{
EventRegistrationBusinessModel EventRegistrationItemt = new EventRegistrationBusinessModel
{
EventRegistrationID = item.EventRegistrationID,
EventDetailsID = item.EventDetailsID,
UserID = item.UserID,
UserAttendance = item.UserAttendance
};
EventRegistrationList.Add(EventRegistrationItemt);
}
}
catch (Exception ex)
{
ExceptionTracker.SendErrorToText(ex);
}
return(EventRegistrationList);
}
/// <summary>
/// convert to the eventdetail entity and pass to the data base layer to update
/// </summary>
/// <param name="eventDetails"></param>
/// <returns></returns>
public bool CreateEvent(EventDetailBusinessModel eventDetails)
{
EventDetail eventDetailToUpdate = new EventDetail();
bool isEventCreated = false;
if (eventDetails != null)
{
try
{
EventDetail newEvent = new EventDetail
{
CreateDate = DateTime.Now,
MdifiedDate = DateTime.Now, EventDate = eventDetails.EventDate,
EventDescription = eventDetails.EventDescription,
EventName = eventDetails.EventName,
EventType = eventDetails.EventType,
CollageID = eventDetails.CollageID
};
adminDataBaseOperation.CreateEvent(newEvent);
isEventCreated = true;
}
catch (Exception ex)
{
ExceptionTracker.SendErrorToText(ex);
isEventCreated = false;
}
}
return(isEventCreated);
}
public CreateUserResponse ResetPassword([FromBody] ResetPasswordRequest pwResetRequest)
{
CreateUserResponse response = new CreateUserResponse();
if (string.IsNullOrEmpty(pwResetRequest.User.Email) ||
string.IsNullOrEmpty(pwResetRequest.User.Password) ||
string.IsNullOrEmpty(pwResetRequest.Token))
{
response.Error = "Missing necessary data";
}
User user = pwResetRequest.User;
using (RequestTracker request = new RequestTracker(Constant.RequestAPI.ResetPW.ToString(), user.Email))
{
try
{
user.Init();
if (string.IsNullOrEmpty(user.Password) || user.Password.Length < 8)
{
request.response = RequestTracker.RequestResponse.UserError;
response.Error = "Password must be at least 8 characters";
return(response);
}
User retrievedUser;
TableStore.Get <User>(TableStore.TableName.users, user.PartitionKey, user.Email, out retrievedUser);
if (retrievedUser == null)
{
request.response = RequestTracker.RequestResponse.UserError;
response.Error = "Invalid user";
return(response);
}
// Confirm token
if (retrievedUser.PWResetTokenWithExpiry == null ||
retrievedUser.PWResetTokenWithExpiry.Item1 != pwResetRequest.Token ||
DateTime.Compare(DateTime.UtcNow, retrievedUser.PWResetTokenWithExpiry.Item2) > 0)
{
request.response = RequestTracker.RequestResponse.UserError;
response.Error = "Invalid or expired token";
return(response);
}
retrievedUser.Password = user.Password;
retrievedUser.EncryptPassword();
retrievedUser.PWResetTokenWithExpiry = null;
retrievedUser.ClearAuthTokens();
string token = retrievedUser.GetAuthToken();
TableStore.Update(TableStore.TableName.users, retrievedUser);
response.Token = token;
response.Error = "Success";
return(response);
}
catch (Exception e)
{
request.response = RequestTracker.RequestResponse.ServerError;
ExceptionTracker.LogException(e);
response.Error = "Oops, something went wrong. Initiating developer punishment.";
return(response);
}
}
}
public void Heal(Character character)
{
ExceptionTracker.IsAlive(this, character);
ExceptionTracker.IsHealSameFraction(this, character);
character.Health += this.AbilityPoints;
}
public CreateUpdateNoteResponse UpdateNote([FromBody] UpdateNoteAction updateNote)
{
CreateUpdateNoteResponse response = new CreateUpdateNoteResponse();
response.Status = string.Empty;
if (string.IsNullOrEmpty(updateNote.Email))
{
return(response);
}
using (RequestTracker request = new RequestTracker(Constant.RequestAPI.UpdateNote.ToString(), updateNote.Email))
{
try
{
if (string.IsNullOrEmpty(updateNote.Email) ||
string.IsNullOrEmpty(updateNote.AuthToken) ||
string.IsNullOrEmpty(updateNote.NoteContents) ||
string.IsNullOrEmpty(updateNote.RowKey))
{
request.response = RequestTracker.RequestResponse.UserError;
return(response);
}
if (updateNote.NoteContents.Length > Constant.MaxNoteLength)
{
request.response = RequestTracker.RequestResponse.UserError;
response.Status = "TooLong";
return(response);
}
// Use the email and authToken to get the userId
string userId = UserController.GetUserId(updateNote.Email, updateNote.AuthToken);
if (string.IsNullOrEmpty(userId))
{
request.response = RequestTracker.RequestResponse.UserError;
// Expired AuthToken
response.Status = "Expired";
return(response);
}
response.Note = NoteModel.UpdateNote(userId, updateNote.RowKey, updateNote.NoteContents, updateNote.City, updateNote.Latitude, updateNote.Longitude, updateNote.Completed);
if (response.Note == null)
{
request.response = RequestTracker.RequestResponse.UserError;
// Expired AuthToken
response.Status = "Invalid";
return(response);
}
LastUpdateModel.SetLastUpdate(userId);
response.Status = "Success";
return(response);
}
catch (Exception e)
{
request.response = RequestTracker.RequestResponse.ServerError;
ExceptionTracker.LogException(e);
return(response);
}
}
}
public void Attack(Character character)
{
ExceptionTracker.IsAlive(this, character);
ExceptionTracker.IsSelfAttack(this, character);
ExceptionTracker.IsFriendlyFire(this, character);
character.TakeDamage(ABILITY_POINTS);
}
public void CreateEvent(EventDetail eventdetail)
{
try
{
db.EventDetails.Add(eventdetail);
db.SaveChanges();
}
catch (Exception ex)
{
ExceptionTracker.SendErrorToText(ex);
}
}
public void UpdateAttendance(EventRegistration attendance)
{
try
{
db.EventEventRegistrations.Add(attendance);
db.SaveChanges();
}
catch (Exception ex)
{
ExceptionTracker.SendErrorToText(ex);
}
}
public void CreaeUser(User userDetail)
{
try
{
db.Users.Add(userDetail);
db.SaveChanges();
}
catch (Exception ex)
{
ExceptionTracker.SendErrorToText(ex);
}
}
public UserRole CreateUserRole(UserRole userRole)
{
try
{
db.UserRoles.Add(userRole);
db.SaveChanges();
return(userRole);
}
catch (Exception ex)
{
ExceptionTracker.SendErrorToText(ex);
return(new UserRole());
}
}
public List <Collage> GetAllCollage()
{
List <Collage> listofCollage = new List <Collage>();
try
{
listofCollage = db.Collages.ToList();
}
catch (Exception ex)
{
ExceptionTracker.SendErrorToText(ex);
}
return(listofCollage);
}
public List <EventDetail> GetAllEventDetail()
{
List <EventDetail> listofEvents = new List <EventDetail>();
try
{
listofEvents = db.EventDetails.ToList();
}
catch (Exception ex)
{
ExceptionTracker.SendErrorToText(ex);
}
return(listofEvents);
}
public EventRegistration UserEventRegistration(EventRegistration eventRegistration)
{
try
{
db.EventEventRegistrations.Add(eventRegistration);
db.SaveChanges();
}
catch (Exception ex)
{
ExceptionTracker.SendErrorToText(ex);
}
return(eventRegistration);
}
/// <summary>
/// Get user detail by user name this will use in different places in the application
/// </summary>
/// <param name="username"></param>
/// <returns></returns>
public User GetUserDetailByUserName(string username)
{
User userdetails = new User();
try
{
userdetails = db.Users.First(c => c.UserName == username);
}
catch (Exception ex)
{
ExceptionTracker.SendErrorToText(ex);
}
return(userdetails);
}
/// <summary>
/// This will use in different places in the application and userrole will return user details and role details
/// </summary>
/// <param name="userID"></param>
/// <returns></returns>
public UserRole GetUserRolebyUserID(int userID)
{
UserRole userdetails = new UserRole();
try
{
userdetails = db.UserRoles.First(c => c.User.UserID == userID);
}
catch (Exception ex)
{
ExceptionTracker.SendErrorToText(ex);
}
return(userdetails);
}
public List <Role> GetAllRoles()
{
List <Role> userRoles = new List <Role>();
try
{
userRoles = db.Roles.ToList();
}
catch (Exception ex)
{
ExceptionTracker.SendErrorToText(ex);
}
return(userRoles);
}
public Role GetRoleDetailsByID(int roleID)
{
Role role = new Role();
try
{
role = db.Roles.Where(c => c.RoleID == roleID).FirstOrDefault();
}
catch (Exception ex)
{
ExceptionTracker.SendErrorToText(ex);
}
return(role);
}
public EventDetail GetEventDetailById(int id)
{
EventDetail eventDetail = new EventDetail();
try
{
eventDetail = db.EventDetails.Where(c => c.EventDetailID == id).FirstOrDefault();
}
catch (Exception ex)
{
ExceptionTracker.SendErrorToText(ex);
}
return(eventDetail);
}
public User GetUserDetailByUserId(int id)
{
User UserDetail = new User();
try
{
UserDetail = db.Users.Where(c => c.UserID == id).FirstOrDefault();
}
catch (Exception ex)
{
ExceptionTracker.SendErrorToText(ex);
}
return(UserDetail);
}
public string UseItem(string[] args)
{
var characterName = args[0];
var itemName = args[1];
var character = party.FirstOrDefault(c => c.Name == characterName);
ExceptionTracker.DoesCharacterExist(character, characterName);
var item = character.Bag.GetItem(itemName);
character.UseItem(item);
return($"{character.Name} used {itemName}.");
}
public List <EventRegistration> ListofEventRegistration(int id)
{
List <EventRegistration> EventRegistrationList = new List <EventRegistration>();
try
{
EventRegistrationList = db.EventEventRegistrations.Where(c => c.EventDetailsID == id).ToList();
}
catch (Exception ex)
{
ExceptionTracker.SendErrorToText(ex);
}
return(EventRegistrationList);
}
public string PickUpItem(string[] args)
{
var characterName = args[0];
var character = party.FirstOrDefault(c => c.Name == characterName);
ExceptionTracker.DoesCharacterExist(character, characterName);
var item = pool.LastOrDefault();
ExceptionTracker.DoesItemExist(item);
pool.Remove(item);
return($"{characterName} picked up {item.GetType().Name}!");
}
public string Heal(string[] args)
{
string healerName = args[0];
string healingReceiverName = args[1];
var healer = party.FirstOrDefault(c => c.Name == healerName);
var receiver = party.FirstOrDefault(c => c.Name == healingReceiverName);
ExceptionTracker.DoesCharacterExist(healer, healerName);
ExceptionTracker.DoesCharacterExist(receiver, healingReceiverName);
((Cleric)healer).Heal(receiver);
return($"{healer.Name} heals {receiver.Name} for {healer.AbilityPoints}!" +
$"{receiver.Name} has {receiver.Health} health now!");
}
public void CreateEvent(EventDetail eventdetail)
{
try
{
EventDetail eventDetail = new EventDetail {
EventDate = eventdetail.EventDate,
EventDescription = eventdetail.EventDescription,
EventName = eventdetail.EventName,
EventType = eventdetail.EventType,
};
}
catch (Exception ex)
{
ExceptionTracker.SendErrorToText(ex);
}
}
public void CreaeUser(UserBusinessModel userDetail)
{
User UserDetails = applicationLevelDataBaseOps.GetUserDetailByUserName(userDetail.UserName);
int roleID = Convert.ToInt32(userDetail.RoleID);
UserBusinessModel returnObject = new UserBusinessModel();
if (UserDetails != null)
{
try
{
User user = new User
{
FirstName = userDetail.FirstName,
LastName = userDetail.LastName,
Password = ApplicationLEvelBusinessOperation.Encrypt(userDetail.Password.Trim()),
UserName = userDetail.UserName,
CollageID = userDetail.CollageID,
CreateDate = DateTime.Now,
MdifiedDate = DateTime.Now
};
List <User> userEntity = new List <User>();
userEntity.Add(adminDataBaseOperation.CreaeUser(user));
returnObject = StaticBusinessMethods.userDetailConvertTOBModel(userEntity).FirstOrDefault();
//UserRole userRole = applicationLevelDataBaseOps.GetUserRolebyUserID(1002);
Role role = applicationLevelDataBaseOps.GetRoleDetailsByID(roleID);
UserRole newUserRole = new UserRole
{
RoleID = roleID,
UderID = returnObject.UserID,
CreateDate = DateTime.Now,
MdifiedDate = DateTime.Now
};
if (role != null)
{
adminDataBaseOperation.CreateUserRole(newUserRole);
}
}
catch (Exception ex)
{
ExceptionTracker.SendErrorToText(ex);
}
}
}
public UserBusinessModel GetUserDetailByUserName(string username)
{
User userdetails = new User();
UserBusinessModel userModelDetails;
try
{
userdetails = applicationLevelDataBaseOps.GetUserDetailByUserName(username);
userModelDetails = new UserBusinessModel {
UserID = userdetails.UserID
};
}
catch (Exception ex)
{
ExceptionTracker.SendErrorToText(ex);
userModelDetails = new UserBusinessModel();
}
return(userModelDetails);
}
