public CustomBoardColumn ModifyColumn(Guid projectId, Guid columnId, string name, string description, int limit)
{
var project = _projectService.GetProjectFromId(projectId);
if(columnId.IsEmpty())
{
var newColumn = new CustomBoardColumn {Name = name, Description = description, CardLimit = limit};
project.AddBoardColumn(newColumn);
_customBoardColumnRepository.Save(newColumn);
_projectService.SaveProject(project);
return newColumn;
}
else
{
var column = project.GetBoardColumns().Where(x => x.Id == columnId).FirstOrDefault();
if(column != null)
{
column.Name = name;
column.Description = description;
column.CardLimit = limit;
_customBoardColumnRepository.Save(column);
return column;
}
}
return null;
}
/// <summary>
/// Gets a task
/// </summary>
/// <param name="taskId">Task identifier</param>
/// <returns>Task</returns>
public virtual ScheduleTask GetById(Guid taskId)
{
if (taskId.IsEmpty())
return null;
return taskRepository.GetById(taskId);
}
/// <summary>
/// Gets an email account by identifier
/// </summary>
/// <param name="emailAccountId">The email account identifier</param>
/// <returns>Email account</returns>
public virtual EmailAccount GetById(Guid emailAccountId)
{
if (emailAccountId.IsEmpty())
return null;
var emailAccount = emailAccountRepository.GetById(emailAccountId);
return emailAccount;
}
/// <summary>
/// Gets a message template
/// </summary>
/// <param name="messageTemplateId">Message template identifier</param>
/// <returns>Message template</returns>
public virtual MessageTemplate GetById(Guid messageTemplateId)
{
if (messageTemplateId.IsEmpty())
return null;
string key = string.Format(MESSAGETEMPLATES_BY_ID_KEY, messageTemplateId);
return cacheManager.Get(key, () =>
{
var manufacturer = messageTemplateRepository.GetById(messageTemplateId);
return manufacturer;
});
}
/// <summary>
/// Gets a company
/// </summary>
/// <param name="companyId">company identifier</param>
/// <returns>A company</returns>
public virtual Company GetById(Guid companyId)
{
if (companyId.IsEmpty())
return null;
string key = string.Format(COMPANY_BY_ID_KEY, companyId);
return this.cacheManager.Get(key, () =>
{
var company = this.companyRepository.GetById(companyId);
return company;
});
}
//create or update
public ActionResult CreateOrUpdatePort(Guid rowId, Guid countryId)
{
var model = new PortModel();
if (rowId.IsEmpty())
model.CountryId = countryId;
else
{
var port = portService.GetById(rowId);
if (port != null)
{
model = port.ToModel();
model.IsEdit = true;
}
}
return PartialView("_CreateOrUpdatePort", model);
}
public ActionResult Create(Guid rowId)
{
var model = new SettingModel()
{
RowId = rowId
};
if (!rowId.IsEmpty())
{
var setting = settingService.GetById(rowId);
if (setting != null)
{
model.Name = setting.Name;
model.Value = setting.Value;
model.IsEdit = true;
}
}
return PartialView("_CreateUpdate", model);
}
/// <summary>
/// Gets a file
/// </summary>
/// <param name="fileId">FileMetaData identifier</param>
/// <returns>FileMetaData</returns>
public virtual FileMetaData GetFileById(Guid fileId)
{
if (fileId.IsEmpty())
return null;
var fileData = fileRepository.GetById(fileId);
return fileData;
}
/// <summary>
/// Gets a port
/// </summary>
/// <param name="portId">The port identifier</param>
/// <returns>port</returns>
public virtual Port GetById(Guid portId)
{
if (portId.IsEmpty())
return null;
string key = string.Format(PORTS_BY_ID_KEY, portId);
return this.cacheManager.Get(key, () =>
{
var port = this.dataRepository.GetById(portId);
return port;
});
}
public void Update(Guid characterId, ICharacterData characterData)
{
if (characterId.IsEmpty()) throw new ArgumentException("characterId");
if (characterData == null) throw new ArgumentNullException("characterData");
throw new NotImplementedException();
}
/// <summary>
/// Gets an activity log type item
/// </summary>
/// <param name="activityLogTypeId">Activity log type identifier</param>
/// <returns>Activity log type item</returns>
public virtual ActivityLogType GetActivityTypeById(Guid activityLogTypeId)
{
if (activityLogTypeId.IsEmpty())
return null;
string key = string.Format(ACTIVITYTYPE_BY_ID_KEY, activityLogTypeId);
return cacheManager.Get(key, () =>
{
return activityLogTypeRepository.GetById(activityLogTypeId);
});
}
public ActionResult Edit(Guid rowId)
{
if (rowId.IsEmpty())
return RedirectToAction(SystemRouteNames.Index);
var client = clientService.GetById(rowId);
if (client == null)
return RedirectToAction(SystemRouteNames.Index);
var model = client.ToModel();
PrepareAddEditModel(model);
var associatedOffices = client.GetAttribute<List<Guid>>(SystemAttributeNames.AssociatedBrancOffices);
if (associatedOffices != null && associatedOffices.Count > 0)
model.OfficeId = associatedOffices.ToDelimitedString();
model.IsEdit = true;
return View(model);
}
public void RemoveUsersFromRoles(Guid[] userIds, string[] roleNames)
{
if (userIds.IsEmpty() || roleNames == null)
{
throw new ArgumentException("Please specify one or more user ids and/or one or more role names.");
}
List<Guid> roleIds = new List<Guid>();
foreach (var name in roleNames)
{
roleIds.Add(this.GetRoleId(name, "user", "remove"));
}
var entries = this._dataSource.Query<UserInRole>().Where(e => userIds.Contains(e.UserId) && roleIds.Contains(e.GroupRole.RoleId));
var groupIds = entries.Select(e => e.GroupRoleGroupId).Distinct().ToArray();
var groupEntries = this._dataSource.Query<GroupInRole>().Where(e => groupIds.Contains(e.GroupId)).ToList();
foreach (var entry in entries)
{
var groupEntry = groupEntries.First(g => g.GroupId == entry.GroupRoleGroupId);
groupEntry.CurrentNumberOfUsers--;
}
this._dataSource.Delete(entries);
_userRoles.Clear();
}
/// <summary>
/// Gets a user
/// </summary>
/// <param name="userId">user identifier</param>
/// <returns>A user</returns>
public virtual Client GetById(Guid clientId)
{
if (clientId.IsEmpty())
return null;
string key = string.Format(CLIENTS_BY_ID_KEY, clientId);
return this.cacheManager.Get(key, () =>
{
var client = this.clientRepository.GetById(clientId);
return client;
});
}
/// <summary>
/// Gets a state/province
/// </summary>
/// <param name="stateProvinceId">The state/province identifier</param>
/// <returns>State/province</returns>
public virtual StateProvince GetById(Guid stateProvinceId)
{
if (stateProvinceId.IsEmpty())
return null;
string key = string.Format(STATEPROVINCES_BY_ID_KEY, stateProvinceId);
return this.cacheManager.Get(key, () =>
{
var category = this.stateProvinceRepository.GetById(stateProvinceId);
return category;
});
}
/// <summary>
/// Gets a locale string resource
/// </summary>
/// <param name="localeStringResourceId">Locale string resource identifier</param>
/// <returns>Locale string resource</returns>
public virtual LocaleStringResource GetLocaleStringResourceById(Guid localeStringResourceId)
{
if (localeStringResourceId.IsEmpty())
return null;
var localeStringResource = this.lsrRepository.GetById(localeStringResourceId);
return localeStringResource;
}
/// <summary>
/// Gets a country
/// </summary>
/// <param name="countryId">Country identifier</param>
/// <returns>Country</returns>
public virtual Country GetById(Guid countryId)
{
if (countryId.IsEmpty())
return null;
string key = string.Format(COUNTRIES_BY_ID_KEY, countryId);
return this.cacheManager.Get(key, () =>
{
var category = this.countryRepository.GetById(countryId);
return category;
});
}
/// <summary>
/// Gets a currency
/// </summary>
/// <param name="currencyId">Currency identifier</param>
/// <returns>Currency</returns>
public virtual Currency GetById(Guid currencyId)
{
if (currencyId.IsEmpty())
return null;
string key = string.Format(CURRENCIES_BY_ID_KEY, currencyId);
return this.cacheManager.Get(key, () => this.currencyRepository.GetById(currencyId));
}
/// <summary>
/// Gets a log item
/// </summary>
/// <param name="logId">Log item identifier</param>
/// <returns>Log item</returns>
public virtual Log GetById(Guid logId)
{
if (logId.IsEmpty())
return null;
var log = logRepository.GetById(logId);
return log;
}
public ActionResult Edit(Guid rowId)
{
if (rowId.IsEmpty())
return RedirectToAction(SystemRouteNames.Index);
var office = dataService.GetById(rowId);
if (office == null)
return RedirectToAction(SystemRouteNames.Index);
var model = office.ToModel();
PrepareAddEditModel(model);
model.IsEdit = true;
return View(model);
}
/// <summary>
/// Gets all activity log items
/// </summary>
/// <param name="createdOnFrom">Log item creation from; null to load all customers</param>
/// <param name="createdOnTo">Log item creation to; null to load all customers</param>
/// <param name="email">Customer Email</param>
/// <param name="userId">user identifier</param>
/// <param name="activityLogTypeId">Activity log type identifier</param>
/// <returns>Activity log collection</returns>
public virtual IList<ActivityLog> GetAllActivities(DateTime? createdOnFrom,
DateTime? createdOnTo, Guid userId, Guid activityLogTypeId)
{
var query = activityLogRepository.Table;
if (createdOnFrom.HasValue)
query = query.Where(al => createdOnFrom.Value <= al.CreatedOn);
if (createdOnTo.HasValue)
query = query.Where(al => createdOnTo.Value >= al.CreatedOn);
if (!activityLogTypeId.IsEmpty())
query = query.Where(al => activityLogTypeId == al.ActivityLogTypeId);
if (!userId.IsEmpty())
{
query = query.Where(c => c.UserId.Equals(userId));
}
query = query.OrderByDescending(al => al.CreatedOn);
return query.ToList();
}
public ActionResult Edit(Guid rowId)
{
if (rowId.IsEmpty())
return RedirectToAction(SystemRouteNames.Index);
var user = userService.GetById(rowId);
if (user == null)
return RedirectToAction(SystemRouteNames.Index);
var model = PrepareUserModel(user);
model.IsEdit = true;
// retrieve extra properties
model.Mobile = encryptionService.AESDecrypt(user.GetAttribute<string>(SystemUserAttributeNames.Mobile), user);
model.IsAdministrator = user.IsInUserRole(SystemUserRoleNames.Administrators);
var associatedOffices = user.GetAttribute<List<Guid>>(SystemAttributeNames.AssociatedBrancOffices);
if (associatedOffices != null && associatedOffices.Count > 0)
model.OfficeId = associatedOffices.ToDelimitedString();
model.AvailableOffices = base.PrepareSelectList(officeService, cacheManager);
return View(model);
}
public IList<AccountStatus> GetAccountStatusData(Guid[] userIds)
{
if (userIds.IsEmpty())
{
return new List<AccountStatus>();
}
return this._dataSource.Query<UserSecurity>().Where(s => userIds.Contains(s.Id)).Select(s => new AccountStatus { Id = s.Id, LockedOut = s.LockedOut, Approved = s.Approved }).ToList();
}
//create or update
public ActionResult CreateOrUpdateState(Guid rowId, Guid countryId)
{
var model = new StateProvinceModel();
if (rowId.IsEmpty())
model.CountryId = countryId;
else
{
var stateProvince = stateProvinceService.GetById(rowId);
if ( stateProvince != null)
{
model = stateProvince.ToModel();
model.IsEdit = true;
}
}
return PartialView("_CreateOrUpdateState", model);
}
/// <summary>
/// Gets a language
/// </summary>
/// <param name="languageId">Language identifier</param>
/// <returns>Language</returns>
public virtual Language GetById(Guid languageId)
{
if (languageId.IsEmpty())
return null;
string key = string.Format(LANGUAGES_BY_ID_KEY, languageId);
return cacheManager.Get(key, () =>
{
return languageRepository.GetById(languageId);
});
}
/// <summary>
/// Gets a branch office
/// </summary>
/// <param name="officeId">office identifier</param>
/// <returns>A branch office</returns>
public virtual BranchOffice GetById(Guid officeId)
{
if (officeId.IsEmpty())
return null;
string key = string.Format(BRANCHOFFICE_BY_ID_KEY, officeId);
return this.cacheManager.Get(key, () =>
{
var branchOffice = this.dataRepository.GetById(officeId);
return branchOffice;
});
}
/// <summary>
/// 设为已读短信（采用事物）
/// </summary>
/// <param name="recordIdList"></param>
/// <returns></returns>
public bool SetReadOper(Guid[] recordIdList)
{
if (recordIdList.IsEmpty())
return false;
using (MySqlConnection conn = new MySqlConnection(MySqlDB.ConnString))
{
conn.Open();
MySqlTransaction trans = conn.BeginTransaction();
MySqlCommand cmd = conn.CreateCommand();
cmd.Transaction = trans;
string sRecordIDstr = recordIdList.JoinToString<Guid>("','");
try
{
cmd.CommandText = string.Format("DELETE FROM gps_websmsanduser_new WHERE recordID in ('{0}')", sRecordIDstr);
cmd.ExecuteNonQuery();
cmd.CommandText = string.Format("UPDATE gps_websmsanduser SET isRead=1, ReadTime='{0}' WHERE recordID in ('{1}')", System.DateTime.Now, sRecordIDstr);
cmd.ExecuteNonQuery();
trans.Commit();
}
catch (Exception ex)
{
Logger.Error("SMSVehicleDAL.SetReadOper('" + sRecordIDstr + "')错误", ex);
try
{
trans.Rollback();
}
catch (Exception exRollback)
{
Logger.Error("SMSVehicleDAL.SetReadOper('" + sRecordIDstr + "')事物回滚错误", exRollback);
}
return false;
}
return true;
}
}
public ICharacterData GetData(Guid characterId, bool throwIfNotFound = true)
{
if (characterId.IsEmpty()) throw new ArgumentException("characterId");
throw new NotImplementedException();
}
/// <summary>
/// Gets a permission
/// </summary>
/// <param name="permissionId">Permission identifier</param>
/// <returns>Permission</returns>
public virtual PermissionRecord GetById(Guid permissionId)
{
if (permissionId.IsEmpty())
return null;
return permissionPecordRepository.GetById(permissionId);
}
/// <summary>
/// Gets an activity log item
/// </summary>
/// <param name="activityLogId">Activity log identifier</param>
/// <returns>Activity log item</returns>
public virtual ActivityLog GetActivityById(Guid activityLogId)
{
if (activityLogId.IsEmpty())
return null;
var query = from al in activityLogRepository.Table
where al.RowId == activityLogId
select al;
var activityLog = query.SingleOrDefault();
return activityLog;
}
