private async Task <BaseModel> Save(LiveEventViewModel model, UsersLoginDataModel user, CommunityGroupsDataModel communityGroupsData)
{
CommunityLiveEvents dataModel = new CommunityLiveEvents
{
CreatedBy = model.UserId,
User = user,
CommunityGroups = communityGroupsData,
ETitle = model.ETitle,
EName = model.EName,
EDescription = model.EDescription,
EFrequency = model.EFrequency,
EFromDate = model.EFromDate,
EToDate = model.EToDate,
ETime = model.ETime,
ETimeDayName = model.ETimeDayName,
ETimeZone = model.ETimeZone,
MaxAttendees = model.MaxAttendees,
Observers = model.Observers,
WhoCanAttend = model.WhoCanAttend,
Participants = model.Participants,
Picture = model.Picture,
IsActive = true,
IsSingleEvent = model.IsSingleEvent
};
await _unitOfWork.UserCommunityLiveEventsRepository.Insert(dataModel);
return(new BaseModel {
Status = true, Id = dataModel.Id, Messsage = UMessagesInfo.RecordSaved
});
}
private async Task <bool> SaveCommunityGroupsThemeAsync(string themesId, UsersLoginDataModel user, CommunityGroupsDataModel communityGroupsData)
{
string[] themes = themesId.Split(',');
var communityGroupTheme = await _unitOfWork.UserCommunityGroupThemeRepository.FindAllBy(c => c.CommunityGroups == communityGroupsData);
foreach (var themeItem in communityGroupTheme)
{
if (themes.Contains(themeItem.CommunityTargetedGroupId.ToString()) == false)
{
themeItem.IsActive = false;
}
else
{
themeItem.IsActive = true;
themes = themes.Where(val => val != themeItem.CommunityTargetedGroupId.ToString()).ToArray();
}
await _unitOfWork.UserCommunityGroupThemeRepository.Update(themeItem);
}
foreach (var item in themes)
{
if (!string.IsNullOrEmpty(item))
{
UserCommunityGroupThemeDataModel userCommunities = new UserCommunityGroupThemeDataModel();
userCommunities.User = user;
userCommunities.IsActive = true;
userCommunities.CommunityGroups = communityGroupsData;
userCommunities.CommunityTargetedGroupId = Convert.ToInt32(item);
await _unitOfWork.UserCommunityGroupThemeRepository.Insert(userCommunities);
}
//Console.WriteLine(item);
}
themes = null;
return(true);
}
private async Task <bool> SaveCommunityTargetedType2Async(string type2Ids, UsersLoginDataModel user, CommunityGroupsDataModel communityGroupsData)
{
string[] type2s = type2Ids.Split(',');
var targetData = await _unitOfWork.UserCommunityTargetedType2Repository.FindAllBy(c => c.CommunityGroups == communityGroupsData);
foreach (var updateItem in targetData)
{
if (type2s.Contains(updateItem.TypeId.ToString()) == false)
{
updateItem.IsActive = false;
}
else
{
updateItem.IsActive = true;
type2s = type2s.Where(val => val != updateItem.TypeId.ToString()).ToArray();
}
await _unitOfWork.UserCommunityTargetedType2Repository.Update(updateItem);
}
foreach (var item in type2s)
{
if (!string.IsNullOrEmpty(item))
{
UserCommunityTargetedType2DataModel type2 = new UserCommunityTargetedType2DataModel();
type2.User = user;
type2.CommunityGroups = communityGroupsData;
type2.TypeId = Convert.ToInt32(item);
type2.IsActive = true;
await _unitOfWork.UserCommunityTargetedType2Repository.Insert(type2);
}
//Console.WriteLine(item);
}
type2s = null;
return(true);
}
private async Task <BaseModel> Save(ArticleViewModel model, UsersLoginDataModel user, CommunityGroupsDataModel communityGroupsData)
{
CommunityArticles dataModel = new CommunityArticles
{
CreatedBy = model.UserId,
User = user,
CommunityGroups = communityGroupsData,
Title = model.ArticleTitle,
Description = model.ArticleDescription,
ShareDocUrl = model.ShareDocument,
IsActive = true,
};
await _unitOfWork.UserCommunityArticlesRepository.Insert(dataModel);
return(new BaseModel {
Status = true, Id = dataModel.Id, Messsage = UMessagesInfo.RecordSaved
});
}
public async Task <BaseModel> SaveAsync(ArticleViewModel model, IFormFile articleShareDocument)
{
try
{
//save with attcahed doc
BaseModel baseModel = new BaseModel();
string articeDocUrl = string.Empty;
string articleFolderPath = "ArcticlesShareDocuments/" + DateTime.Now.Year.ToString();
string articleFileName = string.Empty;
if (articleShareDocument != null && articleShareDocument.Length > 0)
{
articleFileName = Guid.NewGuid().ToString().Replace("-", "") + Path.GetExtension(articleShareDocument.FileName);
articeDocUrl = articleFolderPath + "/" + articleFileName;
model.ShareDocument = articeDocUrl;
}
if (model.Id == 0)
{
UsersLoginDataModel _user = await _unitOfWork.UserLoginRepository.GetByID(model.UserId);
CommunityGroupsDataModel communityGroupsData = await _unitOfWork.UserCommunityGroupsRepository.GetByID(model.CommunityGroupsId);
baseModel = await Save(model, _user, communityGroupsData);
}
else
{
baseModel = await Update(model);
}
if (baseModel.Status == true)
{
if (articleShareDocument != null && articleShareDocument.Length > 0)
{
await _awsS3Bucket.UploadFileAsync(articleFolderPath, articleShareDocument, articleFileName);
}
}
return(baseModel);
}
catch (Exception)
{
return(new BaseModel {
Status = false, Messsage = UMessagesInfo.Error
});
}
}
public async Task <bool> SaveCommunitiesAsync(string communitiesIds, UsersLoginDataModel model)
{
string[] communities = communitiesIds.Split(',');
foreach (var item in communities)
{
if (!string.IsNullOrEmpty(item))
{
UserCommunitiesDataModel userCommunities = new UserCommunitiesDataModel();
userCommunities.User = model;
userCommunities.CommunityId = Convert.ToInt64(item);
userCommunities.IsActive = true;
await _unitOfWork.UserCommunitiesRepository.Insert(userCommunities);
}
//Console.WriteLine(item);
}
communities = null;
return(true);
}
public async Task <BaseModel> SaveEventAsync(LiveEventViewModel model)
{
if (string.IsNullOrEmpty(model.ETime))
{
return(new BaseModel {
Status = false, Messsage = "Please set the event time."
});
}
model.EName = model.ETitle;
if (model.Id == 0)
{
UsersLoginDataModel _user = await _unitOfWork.UserLoginRepository.GetByID(model.UserId);
CommunityGroupsDataModel communityGroupsData = await _unitOfWork.UserCommunityGroupsRepository.GetByID(model.CommunityGroupId);
return(await Save(model, _user, communityGroupsData));
}
else
{
return(await Update(model));
}
}
public async Task <bool> SaveAssociationsAsync(string associationsIds, UsersLoginDataModel user, CommunityDataModel community)
{
if (associationsIds == null)
{
return(false);
}
string[] interests = associationsIds.Split(',');
var _selectedInterests = await _unitOfWork.UserAssociationsRepository.FindAllBy(c => c.User == user && c.Community == community);
foreach (var updateItem in _selectedInterests)
{
if (interests.Contains(updateItem.AssociationId.ToString()) == false)
{
updateItem.IsActive = false;
}
else
{
updateItem.IsActive = true;
interests = interests.Where(val => val != updateItem.AssociationId.ToString()).ToArray();
}
await _unitOfWork.UserAssociationsRepository.Update(updateItem);
}
foreach (var item in interests)
{
if (!string.IsNullOrEmpty(item) && item != "0")
{
UserAssociationsDataModel userGroups = new UserAssociationsDataModel();
userGroups.User = user;
userGroups.Community = community;
userGroups.IsActive = true;
userGroups.AssociationId = Convert.ToInt32(item);
await _unitOfWork.UserAssociationsRepository.Insert(userGroups);
}
//Console.WriteLine(item);
}
return(true);
}
public async Task <BaseModel> SendForgotPasswordLinkAsync(string UserName, string HtmlBody, string verificationActionPath)
{
IList <UsersLoginDataModel> users = await _unitOfWork.UserLoginRepository.FindAllBy(c => c.UserName.ToLower() == UserName);
UsersLoginDataModel userData = users.FirstOrDefault();
if (userData != null)
{
string token = Guid.NewGuid().ToString().Replace("-", "");
RestPasswordLinkDataModel resetPasswordModel = new RestPasswordLinkDataModel {
IsRequestHasUsed = false,
IsRequestToRestPassword = true,
User = userData,
VerificationCode = token
};
var _data = await _unitOfWork.UserProfileRepository.FindAllBy(c => c.User.Id == userData.Id);
if (_data != null)
{
var resetPasswordExistingDetail = await _unitOfWork.RestPasswordLinkRepository.FindAllBy(c => c.User == userData);
RestPasswordLinkDataModel resetPasswordUpdateModel = resetPasswordExistingDetail.FirstOrDefault();
if (resetPasswordUpdateModel == null)
{
await _unitOfWork.RestPasswordLinkRepository.Insert(resetPasswordModel);
}
else
{
resetPasswordUpdateModel.IsRequestToRestPassword = true;
resetPasswordUpdateModel.IsRequestHasUsed = false;
resetPasswordUpdateModel.VerificationCode = token;
await _unitOfWork.RestPasswordLinkRepository.Update(resetPasswordUpdateModel);
}
string messageBody = string.Format(HtmlBody,
verificationActionPath + token,
_data.FirstOrDefault().FirstName + ' ' + _data.FirstOrDefault().LastName,
userData.UserName
);
await _emailSender.SendEmailAsync(
UMessagesInfo.ResetPasswordSubject,
messageBody,
userData.UserName,
_sphixConfiguration.SupportEmail,
UMessagesInfo.SphixSupport
);
return(new BaseModel {
Status = true, Messsage = UMessagesInfo.ResetPasswordLinkSentOnMail
});
}
return(new BaseModel {
Status = false, Messsage = UMessagesInfo.UserNameNotExist
});
}
return(new BaseModel {
Status = false, Messsage = UMessagesInfo.UserNameNotExist
});
}
public JoinOpenHoursMeetingDataModel()
{
OpenOfficeHours = new CommunityOpenOfficeHours();
User = new UsersLoginDataModel();
JoinDateTime = DateTime.Now;
}
private async Task <bool> SaveCommunityTargetedAssociationAsync(string associationIds, UsersLoginDataModel user, CommunityGroupsDataModel communityGroupsData)
{
string[] associations = associationIds.Split(',');
var targetData = await _unitOfWork.UserCommunityTargetedAssociationsRepository.FindAllBy(c => c.CommunityGroups == communityGroupsData);
foreach (var updateItem in targetData)
{
if (associations.Contains(updateItem.AssociationId.ToString()) == false)
{
updateItem.IsActive = false;
}
else
{
updateItem.IsActive = true;
associations = associations.Where(val => val != updateItem.AssociationId.ToString()).ToArray();
}
await _unitOfWork.UserCommunityTargetedAssociationsRepository.Update(updateItem);
}
foreach (var item in associations)
{
if (!string.IsNullOrEmpty(item))
{
UserCommunityTargetedAssociationsDataModel userAssociation = new UserCommunityTargetedAssociationsDataModel();
userAssociation.User = user;
userAssociation.CommunityGroups = communityGroupsData;
userAssociation.AssociationId = Convert.ToInt32(item);
userAssociation.IsActive = true;
await _unitOfWork.UserCommunityTargetedAssociationsRepository.Insert(userAssociation);
}
//Console.WriteLine(item);
}
associations = null;
return(true);
}
public async Task <BaseModel> SendEmailVerification(long Id, string HtmlBody, string verificationActionPath, string Name)
{
bool _actionStatus = false;
UsersLoginDataModel usersLoginData = await _unitOfWork.UserLoginRepository.GetByID(Id);
if (usersLoginData == null)
{
return(new BaseModel {
Status = false, Messsage = UMessagesInfo.WrongUserName
});
}
string token = Guid.NewGuid().ToString().Replace("-", "");
var _resultEmailVerification = await _unitOfWork.EmailVerificatioRepository.FindAllBy(c => c.User.Id == Id);
if (_resultEmailVerification.Count != 0)
{
var emailVerificationUpdateModel = _resultEmailVerification.FirstOrDefault();
emailVerificationUpdateModel.VerificationCode = token;
emailVerificationUpdateModel.IsVerified = false;
await _unitOfWork.EmailVerificatioRepository.Update(emailVerificationUpdateModel);
_actionStatus = true;
}
else
{
EmailVerificationDataModel emailVerificationModel = new EmailVerificationDataModel
{
User = usersLoginData,
EmailAddress = usersLoginData.UserName,
IsVerified = false,
VerificationCode = token
};
await _unitOfWork.EmailVerificatioRepository.Insert(emailVerificationModel);
_actionStatus = true;
}
if (_actionStatus)
{
//active user profile on email verification
usersLoginData.IsActive = true;
usersLoginData.UpdatedBy = Id;
usersLoginData.CreatedBy = Id;
await _unitOfWork.UserLoginRepository.Update(usersLoginData);
//set user information in verification email message
string messageBody = string.Format(HtmlBody,
verificationActionPath + token,
Name,
usersLoginData.UserName
);
await _emailSender.SendEmailAsync(
UMessagesInfo.VerificationEmailSubject,
messageBody,
usersLoginData.UserName,
_sphixConfiguration.SupportEmail,
UMessagesInfo.SphixSupport
);
return(new BaseModel {
Status = true, Messsage = UMessagesInfo.SignUpSuccess
});
}
return(new BaseModel {
Status = true, Messsage = UMessagesInfo.Error
});
}
public JoinCommunityGroupDataModel()
{
CommunityGroup = new CommunityGroupsDataModel();
User = new UsersLoginDataModel();
JoinDateTime = DateTime.Now;
}
public JoinEventMeetingDataModel()
{
LiveEvent = new CommunityLiveEvents();
User = new UsersLoginDataModel();
JoinDateTime = DateTime.Now;
}
private async Task <bool> SaveCommunityTargetedInterestsAsync(string InterestsIds, UsersLoginDataModel user, CommunityGroupsDataModel communityGroupsData)
{
string[] interests = InterestsIds.Split(',');
var targetData = await _unitOfWork.UserCommunityTargetedInterestRepository.FindAllBy(c => c.CommunityGroups == communityGroupsData);
foreach (var updateItem in targetData)
{
if (interests.Contains(updateItem.InterestId.ToString()) == false)
{
updateItem.IsActive = false;
}
else
{
updateItem.IsActive = true;
interests = interests.Where(val => val != updateItem.InterestId.ToString()).ToArray();
}
await _unitOfWork.UserCommunityTargetedInterestRepository.Update(updateItem);
}
foreach (var item in interests)
{
if (!string.IsNullOrEmpty(item))
{
UserCommunityTargetedInterestsDataModel interest = new UserCommunityTargetedInterestsDataModel();
interest.User = user;
interest.CommunityGroups = communityGroupsData;
interest.InterestId = Convert.ToInt32(item);
interest.IsActive = true;
await _unitOfWork.UserCommunityTargetedInterestRepository.Insert(interest);
}
//Console.WriteLine(item);
}
interests = null;
return(true);
}
public async Task <BaseModel> SignUpAsync(SignUpViewModel model)
{
var roleData = await _unitOfWork.RoleRepository.FindAllBy(c => c.RoleName.ToLower() == "user");
if (roleData.Count == 0)
{
return(new BaseModel {
Status = false, Messsage = "no data for user role in role master table"
});
}
model.Email = model.Email.ToLower().Trim();
var existingUser = await _unitOfWork.UserLoginRepository.FindAllBy(c => c.UserName == model.Email);
if (existingUser.Count > 0)
{
existingUser = null;
return(new BaseModel {
Status = false, Messsage = String.Format(UMessagesInfo.UserNameExist, model.Email)
});
}
else
{
string saltValue = Guid.NewGuid().ToString();
string password = UPasswordRijndaelAlgorithm.Encrypt(model.Password, saltValue, _settings.PassPhrase, _settings.HashAlgorithm, _settings.InitVector);
UsersLoginDataModel userLoginData = new UsersLoginDataModel()
{
Password = password,
UserName = model.Email,
PasswordSalt = saltValue,
AddedDate = DateTime.Now,
IsActive = false
};
var userData = await _unitOfWork.UserLoginRepository.Insert(userLoginData);
await _unitOfWork.UsersRolesRepository.Insert(new UsersRolesDataModel { User = userData, Role = roleData.FirstOrDefault() });
//string your_String = "[email protected](Hello)";
string profileLink = Regex.Replace((model.FirstName + model.LastName), @"[^0-9a-zA-Z]+", "").Replace(" ", "");
var profilelinkCheck = await _unitOfWork.UserProfileRepository.FindAllBy(c => c.ProfileLink == profileLink);
if (profilelinkCheck.Count != 0)
{
profilelinkCheck = await _unitOfWork.UserProfileRepository.FindAllBy(c => c.ProfileLink == profileLink + "S00" + userData.Id.ToString());
if (profilelinkCheck.Count != 0)
{
profileLink = Regex.Replace(Guid.NewGuid().ToString(), @"[^0-9a-zA-Z]+", "");
}
else
{
profileLink = profileLink + "S0" + userData.Id.ToString();
}
}
UsersProfileDataModel usersProfileData = new UsersProfileDataModel
{
FirstName = model.FirstName,
LastName = model.LastName,
Email = model.Email,
Phone = model.PhoneNumber,
UseMyLocation = model.UseMyLocation,
Latitude = model.Latitude,
Longitude = model.Longitude,
User = userData,
IsCertifyTAndC = model.IsCertifyTAndC,
IsFinanciallyActive = model.IsFinanciallyActive,
IsKickstartarActive = model.IsKickstartarActive,
AddedDate = DateTime.Now,
ProfileLink = profileLink
};
var profileData = await _unitOfWork.UserProfileRepository.Insert(usersProfileData);
Int64 UserId = usersProfileData.User.Id;
profileData.UpdatedBy = UserId;
profileData.CreatedBy = UserId;
await _unitOfWork.UserProfileRepository.Update(profileData);
profileData = null;
await _userCommunities.SaveCommunitiesAsync(model.CommunityId, userData);
var _mainCommunity = await _unitOfWork.CommunityRepository.GetByID(Convert.ToInt32(model.CommunityId));
if (_mainCommunity != null)
{
await _userCommunities.SaveGroupsAsync(model.GroupId.ToString(), userData, _mainCommunity);
await _userCommunities.SaveAssociationsAsync(model.AssociationId.ToString(), userData, _mainCommunity);
//Save data into the Interests table
await _userCommunities.SaveInterestsAsync(model.InterestsId, userData, _mainCommunity);
//Save data into the community table like group,association
//UserSubCommunitiesDataModel userCommunities = new UserSubCommunitiesDataModel
//{
// User = userData,
// Association = model.AssociationId,
// GroupId = model.GroupId,
// Type1Id = model.Type1ListId,
// Type2ListId = model.Type2ListId,
// Community = _mainCommunity
//};
//await _userCommunities.SaveSubCommunitiesAsync(userCommunities);
//userCommunities = null;
}
userLoginData = null;
usersProfileData = null;
_mainCommunity = null;
userData = null;
return(new BaseModel {
Id = UserId, Status = true, Messsage = UMessagesInfo.SignUpSuccess
});
}
}
public async Task <UserClaimsViewModel> LoginAsync(LoginViewModel model)
{
IList <UsersLoginDataModel> users = await _unitOfWork.UserLoginRepository.FindAllBy(c => c.UserName.ToLower() == model.UserName);
UsersLoginDataModel userData = users.FirstOrDefault();
if (userData != null)
{
try
{
string userPassword = UPasswordRijndaelAlgorithm.Decrypt(userData.Password, userData.PasswordSalt, _settings.PassPhrase, _settings.HashAlgorithm, _settings.InitVector);
if (model.Password.Equals(userPassword))
{
var _query = _unitOfWork.UsersRolesRepository.FindAllByQuery(c => c.User == userData);
var _result = await _query.Include("Role").ToListAsync();
if (_result != null)
{
string roles = string.Empty;
foreach (var item in _result)
{
roles = roles + item.Role.RoleName;// + ",";
}
return(new UserClaimsViewModel {
Status = true, Id = userData.Id, UserName = userData.UserName, Roles = roles
});
}
else
{
return(new UserClaimsViewModel {
Status = false, Messsage = UMessagesInfo.WrongUserName
});
}
}
return(new UserClaimsViewModel {
Status = false, Messsage = UMessagesInfo.WrongUserName
});
}
catch (System.Exception ex)
{
if (ex.Source == "System.Security.Cryptography.Algorithms")
{
//await _loggerService.AddAsync(new Sphix.DataModels.Logger.LoggerDataModel
//{
// ErrorCode = "red",
// Message = ex.Message,
// Source = ex.Source,
// Detail = ex.StackTrace
//});
return(new UserClaimsViewModel {
Status = false, Messsage = "System security settings have changed. Please reset your password!"
});
}
throw;
}
}
else
{
return(new UserClaimsViewModel {
Status = false, Messsage = UMessagesInfo.UserNameNotExist
});
}
}
public GroupEmailInvitationDataModel()
{
LastUpdate = DateTime.Now;
SentByUser = new UsersLoginDataModel();
CommunityGroup = new CommunityGroupsDataModel();
}
/// <summary>
/// Save and update data in Open Office Hours table
/// </summary>
/// <param name="model"></param>
/// <param name="user">if user model is null then please pass UserId into the OpenOfficeHoursViewModel</param>
/// <param name="communityGroupsData">if communityGroupsData model is null then please pass CommunityGroupId into the OpenOfficeHoursViewModel</param>
/// <returns></returns>
public async Task <BaseModel> SaveOpenHoursAsync(OpenOfficeHoursViewModel model, UsersLoginDataModel user, CommunityGroupsDataModel communityGroupsData)
{
if (user == null)
{
user = await _unitOfWork.UserLoginRepository.GetByID(model.UserId);
}
if (communityGroupsData == null)
{
communityGroupsData = await _unitOfWork.UserCommunityGroupsRepository.GetByID(model.CommunityGroupId);
}
if (model.Id == 0)
{
CommunityOpenOfficeHours dataModel = new CommunityOpenOfficeHours
{
CreatedBy = user.Id,
User = user,
CommunityGroups = communityGroupsData,
OTitle = model.OTitle,
OName = model.OName,
ODescription = model.ODescription,
OFrequency = model.OFrequency,
OFromDate = model.OFromDate, // setDateFromDayName(model.OTimeDayName, model.OFromDate),
OToDate = model.OFromDate, // setDateFromDayName(model.OTimeDayName, model.OFromDate),
OTime = model.OTime,
OTimeDayName = model.OTimeDayName,
OTimeZone = model.OTimeZone,
MaxAttendees = model.MaxAttendees,
WhoCanAttend = model.WhoCanAttend,
IsActive = true,
IsFirstMeeting = model.IsFirstMeeting,
NextMeetingToken = model.NextMeetingToken,
LastSessionId = model.LastSessionId,
AddHours = model.AddHours
};
await _unitOfWork.UserCommunityOpenOfficeHoursRepository.Insert(dataModel);
if (model.AddHours)
{
await _context.LoadStoredProc("AddHoursInOpenOfficeHours")
.WithSqlParam("Id", dataModel.Id)
.ExecuteStoredProcAsync((handler) =>
{
// do something with your results.
});
}
return(new BaseModel {
Status = true, Id = dataModel.Id, Messsage = UMessagesInfo.RecordSaved
});
}
else
{
var openOfficeHoursModel = await _unitOfWork.UserCommunityOpenOfficeHoursRepository.GetByID(model.Id);
openOfficeHoursModel.OTitle = model.OTitle;
openOfficeHoursModel.OName = model.OName;
openOfficeHoursModel.ODescription = model.ODescription;
openOfficeHoursModel.OFrequency = model.OFrequency;
if (openOfficeHoursModel.OTimeDayName.ToLower().Trim() != model.OTimeDayName.ToLower().Trim())
{
openOfficeHoursModel.OFromDate = SphixHelper.setDateFromDayName(model.OTimeDayName, DateTime.Now.Date);
openOfficeHoursModel.OToDate = openOfficeHoursModel.OFromDate;
}
else
{
openOfficeHoursModel.OFromDate = model.OFromDate;// setDateFromDayName(model.OTimeDayName, model.OFromDate);
openOfficeHoursModel.OToDate = openOfficeHoursModel.OFromDate;
}
openOfficeHoursModel.OTime = model.OTime;
openOfficeHoursModel.OTimeDayName = model.OTimeDayName;
openOfficeHoursModel.OTimeZone = model.OTimeZone;
openOfficeHoursModel.MaxAttendees = model.MaxAttendees;
openOfficeHoursModel.WhoCanAttend = model.WhoCanAttend;
openOfficeHoursModel.IsActive = true;
//openOfficeHoursModel.AddHours = model.AddHours;
//openOfficeHoursModel.IsFirstMeeting = model.IsFirstMeeting;
await _unitOfWork.UserCommunityOpenOfficeHoursRepository.Update(openOfficeHoursModel);
return(new BaseModel {
Status = true, Id = model.Id, Messsage = UMessagesInfo.RecordSaved
});
}
}
private async Task <BaseModel> Save(CommunityGroupViewModel model, UsersLoginDataModel user, string articeDoclUrl)
{
try
{
if (string.IsNullOrEmpty(model.TargetedInterestIds) && model.IsPublicGroup == false)
{
return(new BaseModel {
Status = false, Messsage = "Please select Interest"
});
}
CommunityGroupsDataModel communityGroupModel = new CommunityGroupsDataModel
{
CreatedBy = model.UserId,
User = user,
Title = model.Title,
CommunityGroupURL = Urlhelper.GenerateSeoFriendlyURL(model.Title),
Description = model.Description,
DescriptionVideoUrl = model.DescriptionVideoUrl,
IsActive = true,
IsPublish = false,
IsPublicGroup = model.IsPublicGroup,
CommunityId = model.OgranizationsId
};
await _unitOfWork.UserCommunityGroupsRepository.Insert(communityGroupModel);
//if group is not public then data will save in relation tables
if (!model.IsPublicGroup)
{
//saveing data in relation tables
await SaveCommunityTargetedGroupsAsync(model.CommunityTargetedGroupId, user, communityGroupModel);
await SaveCommunityTargetedAssociationAsync(model.AssociationId, user, communityGroupModel);
//await SaveCommunityTargetedType1Async(model.Type1Id, user, communityGroupModel);
//await SaveCommunityTargetedType2Async(model.Type2Id, user, communityGroupModel);
await SaveCommunityTargetedInterestsAsync(model.TargetedInterestIds, user, communityGroupModel);
}
await SaveCommunityGroupsThemeAsync(model.ThemesId, user, communityGroupModel);
//SaveOpenHours
OpenOfficeHoursViewModel OpenOfficeHoursModel = JsonConvert.DeserializeObject <OpenOfficeHoursViewModel>(model.OpenOfficeHours);
OpenOfficeHoursModel.OFromDate = SphixHelper.setDateFromDayName(OpenOfficeHoursModel.OTimeDayName, DateTime.Now.Date);
OpenOfficeHoursModel.OToDate = OpenOfficeHoursModel.OFromDate;
OpenOfficeHoursModel.IsFirstMeeting = true;
await _openOfficeHoursService.SaveOpenHoursAsync(OpenOfficeHoursModel, user, communityGroupModel);
//SaveLiveEvent
LiveEventViewModel LiveEventModel = JsonConvert.DeserializeObject <LiveEventViewModel>(model.LiveEvent);
await SaveLiveEvent(LiveEventModel, user, communityGroupModel);
//SaveArticles
ArticleViewModel ArticleModel = JsonConvert.DeserializeObject <ArticleViewModel>(model.Article);
ArticleModel.ShareDocument = articeDoclUrl;
await SaveArticles(ArticleModel, user, communityGroupModel);
return(new BaseModel {
Status = true, Id = communityGroupModel.Id, Messsage = UMessagesInfo.RecordSaved
});
}
catch (Exception ex)
{
return(new BaseModel {
Status = false, Messsage = UMessagesInfo.Error
});
}
}
