public async Task <IActionResult> Create(MembershipDTO membershipDTO)
{
Membership membership = new Membership();
_mapper.Map(membershipDTO, membership);
await membershipRepository.AddAsync(membership);
return(Ok());
}
public async Task <ActionResult> Add([FromHeader] string Authentication, [FromQuery] string userId, [FromQuery] string groupId)
{
if (SessionManager.GetSessionState(Authentication) != SessionManager.SessionState.Authorized)
{
return(Unauthorized());
}
SessionInfo sessionInfo = SessionManager.GetSessionInfo(Authentication);
if (sessionInfo == null)
{
return(Unauthorized());
}
int userIdInt = 0;
int groupIdInt = 0;
if (!int.TryParse(userId, out userIdInt) || !int.TryParse(userId, out groupIdInt))
{
return(BadRequest("Bad id"));
}
using (UnitOfWork uow = new UnitOfWork())
{
MembershipRepository membershipRepo = new MembershipRepository(uow);
MembershipDTO membership = await membershipRepo.GetByUserAndGroupId(userIdInt, groupIdInt);
if (membership != null)
{
if (membership.Status == 0 && userIdInt == sessionInfo.UserId)
{
membership.Status = 1;
await membershipRepo.Update(membership);
}
else
{
return(Ok());
}
}
else
{
membership = new MembershipDTO
{
UserId = userIdInt,
GroupId = groupIdInt,
Status = 0
};
membership.Id = await membershipRepo.Add(membership);
}
uow.Commit();
return(Ok(membership));
}
}
public async Task <ActionResult <MembershipDTO> > GetAction(string id)
{
var membership = await membershipRepository.GetDetailAsync(id);
if (membership == null)
{
return(NotFound());
}
MembershipDTO membershipDTO = new MembershipDTO();
_mapper.Map(membership, membershipDTO);
return(Ok(membershipDTO));
}
public async Task <IActionResult> Update(string id, MembershipDTO membershipDTO)
{
Membership membership = await membershipRepository.GetDetailAsync(id);
if (membership == null)
{
return(NotFound());
}
membershipDTO.MembershipCode = id;
_mapper.Map(membershipDTO, membership);
await membershipRepository.UpdateAsync(membership);
return(Ok());
}
public async Task <ActionResult> Add([FromHeader] string Authentication, [FromBody] GroupDTO group)
{
if (SessionManager.GetSessionState(Authentication) != SessionManager.SessionState.Authorized)
{
return(Unauthorized());
}
SessionInfo sessionInfo = SessionManager.GetSessionInfo(Authentication);
if (sessionInfo == null)
{
return(Unauthorized());
}
if (string.IsNullOrEmpty(group.Name) || string.IsNullOrEmpty(group.DefaultCurrency) ||
!Currencies.CurrenciesList.Contains(group.DefaultCurrency))
{
return(BadRequest());
}
group.CreatedDate = DateTime.Now;
using (UnitOfWork uow = new UnitOfWork())
{
GroupsRepository groupsRepository = new GroupsRepository(uow);
group.Id = await groupsRepository.Add(group);
MembershipDTO membership = new MembershipDTO
{
UserId = sessionInfo.UserId,
GroupId = group.Id,
Status = 3
};
MembershipRepository membershipRepository = new MembershipRepository(uow);
await membershipRepository.Add(membership);
uow.Commit();
}
return(Ok());
}
public async Task <ActionResult> Delete([FromHeader] string Authentication, [FromQuery] string userId, [FromQuery] string groupId)
{
if (SessionManager.GetSessionState(Authentication) != SessionManager.SessionState.Authorized)
{
return(Unauthorized());
}
SessionInfo sessionInfo = SessionManager.GetSessionInfo(Authentication);
if (sessionInfo == null)
{
return(Unauthorized());
}
int userIdInt = 0;
int groupIdInt = 0;
if (!int.TryParse(userId, out userIdInt) || !int.TryParse(userId, out groupIdInt))
{
return(BadRequest("Bad id"));
}
using (UnitOfWork uow = new UnitOfWork())
{
MembershipRepository membershipsRepo = new MembershipRepository(uow);
MembershipDTO membership = await membershipsRepo.GetByUserAndGroupId(userIdInt, groupIdInt);
if (membership.Status == 3)
{
return(BadRequest("cannot delete the owner"));
}
await membershipsRepo.Remove(membership.Id);
uow.Commit();
return(Ok());
}
}
public ActionResult RegisterConfimation(string un, string ct)
{
string urlAction;
string unDecrypted = un; // EncryptionUtility.Decrypt(un);
if (WebSecurity.ConfirmAccount(unDecrypted, ct))
{
urlAction = "Login";
//get userid of received username
int userid = new UserService(true).GetByName(unDecrypted).UserId;
//Account Confirmation should be propagated to the local server database through sync
using (IDbContext dbCon = DbContextUtil.GetDbContextInstance())
{
MembershipDTO membershipDTO = dbCon.Set <MembershipDTO>().FirstOrDefault(m => m.UserId == userid);
if (membershipDTO != null)
{
membershipDTO.DateLastModified = DateTime.Now;
dbCon.Set <MembershipDTO>().Add(membershipDTO);
dbCon.Entry(membershipDTO).State = EntityState.Modified;
dbCon.SaveChanges();
}
}
}
else
{
urlAction = "ConfirmationFailure";
}
return(RedirectToAction(urlAction, new UserCompanyDetail
{
CompanyName = unDecrypted,
AddNewVisaVisibility = ct,
AddNewEmployeeVisibility = un
}));
}
public ActionResultApi <MembershipDTO> update([FromBody] MembershipDTO model)
{
return(new ActionResultApi <MembershipDTO>(HttpStatusCode.OK, membershipDAL.update(model), Request));
}
public bool SyncMemberships(IUnitOfWork sourceUnitOfWork, IUnitOfWork destinationUnitOfWork)
{
var sourceList = sourceUnitOfWork.UserRepository <MembershipDTO>().Query()
//.Filter(a => a.DateLastModified > LastServerSyncDate)
.Get(1).ToList();
var sourceUsers = sourceUnitOfWork.UserRepository <UserDTO>().Query()
.Get(1).ToList();
if (sourceList.Any())
{
//_updatesFound = true;
var destUsers =
destinationUnitOfWork.UserRepository <UserDTO>().Query()
.Filter(a => a.AgencyId == Singleton.Agency.Id)
.Get(1).ToList();
//var destRoles = destinationUnitOfWork.UserRepository<RoleDTO>().Query().Get(1).ToList();
//var destList =
// destinationUnitOfWork.UserRepository<MembershipDTO>().Query()
// .Get(1).ToList();
foreach (var source in sourceList)
{
//var destination =
// destList.FirstOrDefault(i => i.RowGuid == source.RowGuid);
MembershipDTO source1 = source;
var destination = destinationUnitOfWork.UserRepository <MembershipDTO>().Query()
.Filter(i => i.RowGuid == source1.RowGuid).Get(1).FirstOrDefault();
var id = 0;
if (destination == null)
{
destination = new MembershipDTO();
}
else
{
continue;
//id = destination.UserId;
}
try
{
Mapper.Reset();
Mapper.CreateMap <MembershipDTO, MembershipDTO>()
.ForMember("Synced", option => option.Ignore());
destination = Mapper.Map(source, destination);
destination.Id = id;
destination.CreatedByUserId = GetDestCreatedModifiedByUserId(source.CreatedByUserId,
sourceUnitOfWork, destinationUnitOfWork);
destination.ModifiedByUserId = GetDestCreatedModifiedByUserId(source.ModifiedByUserId,
sourceUnitOfWork, destinationUnitOfWork);
}
catch (Exception ex)
{
LogUtil.LogError(ErrorSeverity.Critical, "SyncMemberships Mapping",
ex.Message + Environment.NewLine + ex.InnerException, UserName, Agency);
}
try
{
var userguid = sourceUsers.FirstOrDefault(c => c.UserId == source.UserId);
var userDto =
destUsers.FirstOrDefault(c => userguid != null && c.RowGuid == userguid.RowGuid);
{
//users.User = userDto;
destination.UserId = userDto != null ? userDto.UserId : 1;
}
if (id == 0)
{
destinationUnitOfWork.UserRepository <MembershipDTO>()
.Insert(destination);
}
else
{
destinationUnitOfWork.UserRepository <MembershipDTO>()
.Update(destination);
}
}
catch
{
//_errorsFound = true;
LogUtil.LogError(ErrorSeverity.Critical, "SyncMemberships Crud",
"Problem On SyncMemberships Crud Method", UserName, Agency);
//return false;
}
}
var changes = destinationUnitOfWork.Commit();
if (changes < 0)
{
_errorsFound = true;
LogUtil.LogError(ErrorSeverity.Critical, "SyncMemberships Commit",
"Problem Commiting SyncMemberships Method", UserName, Agency);
return(false);
}
}
return(true);
}
public MembershipDTO update(MembershipDTO model)
{
return((MembershipDTO)membershipRepository.edit(model));
}
public MembershipDTO create(MembershipDTO model)
{
return((MembershipDTO)membershipRepository.create(model));
}
