public async Task <VehicleMakesDto> GetVehicleMakes(int siteId)
{
using (var uow = UowManager.CurrentOrCreateNew(true))
{
return(new VehicleMakesDto(await((IVehicleDomainService)DomainService).GetMakes(siteId)));
}
}
public async Task <PaginatedResponseDto <ResourceDto> > GetAllAsync(ResourcePaginatedRequestDto request)
{
using (var uow = UowManager.Begin())
using (UowManager.Current.OverrideCurrentLanguageCode(request.LanguageCode ?? Session.LanguageCode))
{
var options = request.ResolveRepositoryGetAllProjectedOptions(ResourceDto.Projection);
var dtos = await _resourceRepository.GetAllListAsync(
x =>
(!request.WithId.HasValue || (request.WithId.HasValue && request.WithId.Value == x.Id)) &&
(string.IsNullOrEmpty(request.WithKey) || (!string.IsNullOrEmpty(request.WithKey) && request.WithKey == x.Key)) &&
(!request.MustBePublic.HasValue || (request.MustBePublic.HasValue && request.MustBePublic == !x.ResourceGroup.IsPrivate))
, options
, out long total);
if (dtos is null)
{
throw new AppException();
}
return(new PaginatedResponseDto <ResourceDto>(dtos)
{
PageIndex = request.PageIndex,
PageSize = request.PageSize,
Total = total
});
}
}
public async Task <GetAllResponse <InvitationDto> > GetAllCreatedInvitationsAsync(int id, uint page = 0, uint pageSize = 0, string sorting = null)
{
Expression <Func <Invitation, bool> > filter = (entity) => entity.InvitatorId == id;
int totalCount;
IList <Invitation> entities;
int skip = (int)(page * pageSize);
int take = (int)pageSize;
using (var uow = UowManager.CurrentOrCreateNew(true))
{
entities = await InvitationDomainService.RetrieveAllAsync(filter, sorting, skip, take);
totalCount = take > 0 || skip > 0 && (entities.Count == take || skip != 0) ?
await InvitationDomainService.GetTotalCountAsync(filter) :
entities.Count;
}
List <InvitationDto> entityDtos = new List <InvitationDto>(entities.Count);
foreach (Invitation entity in entities)
{
InvitationDto entityDto = new InvitationDto();
entityDto.MapFromEntity(entity);
entityDto.NormalizeAsResponse();
entityDtos.Add(entityDto);
}
return(new GetAllResponse <InvitationDto>(entityDtos, totalCount));
}
public async Task <ImportVehiclesShapshot> ImportVehiclesAsync(int siteId)
{
string message;
ImportStatusEnum status;
ImportVehiclesForSiteResult importResult;
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
try
{
using (var uow = UowManager.CurrentOrCreateNew(true))
{
importResult = await((ISiteDomainService)DomainService).ImportVehiclesAsync(siteId);
await uow.CompleteAsync();
}
status = ImportStatusEnum.Success;
message = null;
}
catch (Exception ex)
{
status = ImportStatusEnum.Failed;
message = ex.Message;
importResult = null;
}
stopWatch.Stop();
ImportVehiclesShapshot importSnapshot = new ImportVehiclesShapshot(
stopWatch.Elapsed, status, message,
new List <ImportVehiclesForSiteResultDto>()
{
new ImportVehiclesForSiteResultDto(importResult)
});
return(importSnapshot);
}
public async Task RegisterAsync([FromBody] UserFullDto request, string invitationCode)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
request.NormalizeAsRequest();
using (var uow = UowManager.CurrentOrCreateNew(true))
{
if (!(await((IUserDomainService)DomainService).IsUsernameValidAsync(request.Username)))
{
throw new ValidateEntityPropertiesException(nameof(request.Username));
}
Invitation invitation = await InvitationDomainService.UseInvitationAsync(invitationCode);
User newUser = request.MapToEntity();
newUser.MaxSitesCount = invitation.AvailableSitesCount;
newUser.UserRoles = new List <UserRole>()
{
new UserRole()
{
User = newUser, RoleId = invitation.RoleId
}
};
await DomainService.CreateAsync(newUser);
await uow.CompleteAsync();
}
}
protected virtual async Task <ImportVehiclesShapshot> InnerImportVehiclesAsync()
{
string message;
ImportStatusEnum status;
IEnumerable <ImportVehiclesForSiteResult> importResults;
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
try
{
using (var uow = UowManager.CurrentOrCreateNew(true))
{
importResults = await((ISiteDomainService)DomainService).ImportVehiclesAsync();
await uow.CompleteAsync();
}
status = ImportStatusEnum.Success;
message = null;
}
catch (Exception ex)
{
status = ImportStatusEnum.Failed;
message = ex.Message;
importResults = null;
}
stopWatch.Stop();
ImportVehiclesShapshot importSnapshot = new ImportVehiclesShapshot(
stopWatch.Elapsed, status, message,
importResults.Select(importResult => new ImportVehiclesForSiteResultDto(importResult)));
// do not await this
LogImportSnapshot(importSnapshot);
return(importSnapshot);
}
public async Task PatchIsReachedByManagerAsync([FromBody] PatchBoolPropertyRequest request, int id)
{
using (var uow = UowManager.CurrentOrCreateNew(true))
{
await((ILeadDomainService)DomainService).ChangeIsReachedByManagerAsync(id, request.Value);
await uow.CompleteAsync();
}
}
protected virtual async Task SwapOrdersAsync(TPrimaryKey key1, TPrimaryKey key2)
{
using (var uow = UowManager.CurrentOrCreateNew(true))
{
await((IEntityExtendedDomainService <TEntity, TPrimaryKey>)DomainService).SwapOrdersAsync(key1, key2);
await uow.CompleteAsync();
}
}
protected virtual async Task ChangeOrderAsync(TPrimaryKey id, int newValue)
{
using (var uow = UowManager.CurrentOrCreateNew(true))
{
await((IEntityExtendedDomainService <TEntity, TPrimaryKey>)DomainService).ChangeOrderAsync(id, newValue);
await uow.CompleteAsync();
}
}
public async Task ChangeContactsAsync(int id, [FromBody] ChangeContactsRequest request)
{
using (var uow = UowManager.CurrentOrCreateNew(true))
{
await((ISiteDomainService)DomainService).ChangeContactsAsync(id, request.Value);
await uow.CompleteAsync();
}
}
public async Task ChangeIsResolvedAsync(int id, [FromBody] PatchBoolPropertyRequest request)
{
using (var uow = UowManager.CurrentOrCreateNew(true))
{
await((IWidgetEventDomainService)DomainService).ChangeIsResolvedAsync(id, request.Value);
await uow.CompleteAsync();
}
}
public async Task PatchPersonalInfo([FromBody] PatchPersonalInfoRequest request, int id)
{
using (var uow = UowManager.CurrentOrCreateNew(true))
{
await((IUserDomainService)DomainService)
.UpdatePersonalInfoAsync(id, request.FirstName, request.SecondName, request.Email, request.PhoneNumber);
await uow.CompleteAsync();
}
}
public async Task PatchPassword([FromBody] PatchAvatarRequest request, int id)
{
using (var uow = UowManager.CurrentOrCreateNew(true))
{
await((IUserDomainService)DomainService)
.UpdateAvatarAsync(id, request.NewAvatarUrl);
await uow.CompleteAsync();
}
}
public async Task DeleteInvitationAsync(int id)
{
using (var uow = UowManager.CurrentOrCreateNew(true))
{
await InvitationDomainService.DeleteAsync(id);
await uow.CompleteAsync();
}
}
/// <summary>
/// Is used as inner delete method for entity
/// </summary>
/// <param name="id">entity id</param>
/// <returns>deletion task</returns>
protected virtual async Task InnerDeleteAsync(TPrimaryKey id)
{
using (var uow = UowManager.CurrentOrCreateNew(true))
{
await DomainService.DeleteAsync(id);
await uow.CompleteAsync();
}
}
public async Task <SiteWeekSchedule> GetWeekScheduleAsync(int id)
{
SiteWeekSchedule schedule;
using (var uow = UowManager.CurrentOrCreateNew(true))
{
schedule = new SiteWeekSchedule(id, await((ISiteDomainService)DomainService).RetrieveWeekSchedule(id));
}
return(schedule);
}
public async Task <bool> ValidateCredentialsAsync(User user, string password)
{
using (var uow = UowManager.Begin())
{
UowManager.Current.DisableMayHaveTenantBaseFilter();
UowManager.Current.DisableMustHaveTenantBaseFilter();
return(await _userManager.CheckPasswordAsync(user, password));
}
}
public async Task <User> FindByUsernameAsync(string username)
{
using (var uow = UowManager.Begin())
{
UowManager.Current.DisableMayHaveTenantBaseFilter();
UowManager.Current.DisableMustHaveTenantBaseFilter();
return(await _userManager.FindByNameAsync(username));
}
}
public Task SignInAsync(User user, AuthenticationProperties properties, string authenticationMethod = null)
{
using (var uow = UowManager.Begin())
{
UowManager.Current.DisableMayHaveTenantBaseFilter();
UowManager.Current.DisableMustHaveTenantBaseFilter();
return(_signInManager.SignInAsync(user, properties, authenticationMethod));
}
}
public async Task <IEnumerable <VehicleModelInfoDto> > GetVehicleModels(int siteId, string make, string sorting = "Name asc")
{
using (var uow = UowManager.CurrentOrCreateNew(true))
{
return((await((IVehicleDomainService)DomainService)
.GetModels(siteId, make))
.Select(vehicleModelInfo => new VehicleModelInfoDto(vehicleModelInfo))
.AsQueryable()
.OrderBy(sorting));
}
}
public async Task <int> CreateArtwork(ArtworkCreateInputDto inputDto)
{
using (var uow = UowManager.Begin())
{
try
{
var hasItem = inputDto.ItemIds != null && inputDto.ItemIds.Any();
List <ArtworkItem> items = new List <ArtworkItem>();
if (hasItem)
{
items = _artworkItems.GetList(i => inputDto.ItemIds.Contains(i.Id));
var notExistItems = inputDto.ItemIds.Except(items.Select(i => i.Id)).ToList();
if (notExistItems.Any())
{
throw new Exception($"these item are not exist: {string.Join(",", notExistItems.Select(i => $"[{i}]"))}");
}
}
var artworkCreateResult = await _artworks.InsertAsync(new Artwork
{
Name = inputDto.Name,
Description = inputDto.Description,
CoverImage = inputDto.CoverImage,
CompletionTime = inputDto.CompletionTime,
OnTop = inputDto.OnTop,
});
var id = artworkCreateResult.Id;
if (hasItem)
{
for (var i = 0; i < items.Count; i++)
{
var item = items[i];
item.ArtworkId = id;
item.Seq = i;
}
await _artworkItems.UpdateAsync(items);
}
uow.Commit();
return(id);
}
catch (Exception ex)
{
uow.Rollback();
throw new Exception("failed to save");
}
}
}
protected void LogContextInfo(IMessageHandlerContext context)
{
if (AbpNServiceBusModuleConfig.Debug)
{
Logger.DebugFormat("Message: {0}", context.MessageId);
Logger.DebugFormat("Message/AbpSession: {0}/{1}", context.MessageId, AbpSession.GetHashCode());
Logger.DebugFormat("Message/UowManager: {0}/{1}", context.MessageId, UowManager.GetHashCode());
if (UowManager.Current != null)
{
Logger.DebugFormat("Message/UnitOfWork: {0}/{1}", context.MessageId, UowManager.Current.GetHashCode());
}
}
}
/// <summary>
/// Is used as inner get method for entity (returns full version of entity)
/// </summary>
/// <param name="id">entity id</param>
/// <returns>entity as result of task</returns>
protected virtual async Task <TEntityFullDto> InnerGetAsync(TPrimaryKey id)
{
TEntity entity;
using (var uow = UowManager.CurrentOrCreateNew(true))
{
entity = await DomainService.RetrieveAsync(id);
}
TEntityFullDto response = new TEntityFullDto();
response.MapFromEntity(entity);
response.NormalizeAsResponse();
return(response);
}
/// <summary>
/// Is used to retrieve all entities via filters and sorting as paged result
/// </summary>
/// <param name="filter">filter</param>
/// <param name="sorting">sorting as string like "prop1 asc, prop2 desc"</param>
/// <param name="page">page number (starts from 0)</param>
/// <param name="pageSize">page size (count of elements on the page)</param>
/// <returns>object with retrieved items and total count</returns>
protected virtual async Task <GetAllResponse <TEntityDto> > InnerGetAllAsync(Expression <Func <TEntity, bool> > filter, string sorting, uint page, uint pageSize)
{
int totalCount;
IList <TEntity> entities;
int skip = (int)(page * pageSize);
int take = (int)pageSize;
using (var uow = UowManager.CurrentOrCreateNew(true))
{
entities = await DomainService.RetrieveAllAsync(filter, sorting, skip, take);
totalCount = take > 0 || skip > 0 && (entities.Count == take || skip != 0) ? await DomainService.GetTotalCountAsync(filter) : entities.Count;
}
return(new GetAllResponse <TEntityDto>(MapEntitiesToDtos <TEntity, TEntityDto>(entities), totalCount));
}
/// <summary>
/// Is used as inner update method for entity (updates entity and returns it back via <see cref="InnerGetAsync(TPrimaryKey)"/>)
/// </summary>
/// <param name="request">request</param>
/// <returns>updated entity as result of task</returns>
/// <exception cref="ArgumentNullException">Thrown when request is null</exception>
protected virtual async Task <TEntityFullDto> InnerUpdateAsync(TEntityFullDto request)
{
if (request == null)
{
throw new ArgumentNullException("Request");
}
request.NormalizeAsRequest();
using (var uow = UowManager.CurrentOrCreateNew(true))
{
await DomainService.UpdateAsync(request.MapToEntity());
await uow.CompleteAsync();
}
return(await InnerGetAsync(request.Id));
}
public async Task CreateAsync([FromBody] WidgetEventFullDto request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
request.NormalizeAsRequest();
using (var uow = UowManager.CurrentOrCreateNew(true))
{
await DomainService.CreateAsync(request.MapToEntity());
await uow.CompleteAsync();
}
}
public async Task PatchPassword([FromBody] PatchPasswordRequest request, int id)
{
try
{
using (var uow = UowManager.CurrentOrCreateNew(true))
{
await((IUserDomainService)DomainService)
.UpdatePasswordAsync(id, request.OldPassword, request.NewPassword);
await uow.CompleteAsync();
}
}
catch (PasswordIsNotValidException)
{
Response.StatusCode = (int)HttpStatusCode.Unauthorized;
}
}
public async Task <bool> ModifyArtwork(ArtworkModifyInputDto inputDto)
{
if (!TryGetEntityById <Artwork>(inputDto.Id, out var artwork))
{
throw new Exception("artwork not exist");
}
using (var uow = UowManager.Begin())
{
try
{
artwork.Name = inputDto.Name;
artwork.Description = inputDto.Description;
artwork.CompletionTime = inputDto.CompletionTime;
artwork.OnTop = inputDto.OnTop;
artwork.CoverImage = inputDto.CoverImage;
await _artworks.UpdateAsync(artwork);
if (inputDto.ItemIds == null)
{
inputDto.ItemIds = new int[] { };
}
// delete old items
_artworkItems.Update(i => i.ArtworkId == inputDto.Id, i => i.ArtworkId = 0);
// add new items
var items = _artworkItems.GetList(i => inputDto.ItemIds.Contains(i.Id));
for (var i = 0; i < items.Count; i++)
{
var item = items[i];
item.ArtworkId = inputDto.Id;
item.Seq = inputDto.ItemIds.ToList().IndexOf(item.Id);
}
await _artworkItems.UpdateAsync(items);
uow.Commit();
return(true);
}
catch (Exception ex)
{
uow.Rollback();
throw new Exception("failed to modify");
}
}
}
public async Task <string> ExportDataToExcelAsync([FromBody] LeadGetAllRequest request, uint?page = null, uint?pageSize = null)
{
Uri fileUrl;
TimeSpan timeZoneOffset = TimeSpan.Zero;
string fileName = $"TestDrive-Leads-{DateTime.UtcNow.FormatUtcDateTimeToUserFriendlyString(timeZoneOffset, "yyyyMMddHHmmss")}";
string worksheetsName = "leads";
using (var uow = UowManager.CurrentOrCreateNew(true))
{
ExcelExportSettings <Lead> settings = new ExcelExportSettings <Lead>(
fileName, worksheetsName,
DomainService, ContentManager,
ExcelExportLeadOptionsProvider.GetEntityOptions((r) => r.UseByDefault, (key) => key, timeZoneOffset),
BuildRetrieveManyFilter(request), request.Sorting, page ?? 0 * pageSize ?? 0, pageSize);
fileUrl = await ExcelExportService <Lead> .ExportDataAsync(settings);
}
return(fileUrl.ToString());
}
/// <summary>
/// Is used as inner create method for entity (creates entity and returns it back via <see cref="InnerGetAsync(TPrimaryKey)"/>)
/// </summary>
/// <param name="request">request</param>
/// <returns>created entity as result of task</returns>
/// <exception cref="ArgumentNullException">Thrown when request is null</exception>
protected virtual async Task <TEntityFullDto> InnerCreateAsync(TEntityFullDto request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
request.NormalizeAsRequest();
TPrimaryKey entityId;
using (var uow = UowManager.CurrentOrCreateNew(true))
{
TEntity stubEntity = await DomainService.CreateAsync(request.MapToEntity());
await uow.CompleteAsync();
entityId = stubEntity.Id;
}
return(await InnerGetAsync(entityId));
}
