public EntityResponse <int> GetLogsCountForEntityAction(EntityType type, LogType action, DateTime?start, DateTime?end)
{
var res = new EntityResponse <int>();
res.Success = true;
try
{
switch (action)
{
case LogType.Purchase:
res.Entity = _purchRep.GetMusicsPurchaseCount(start, end);
break;
case LogType.MusicView:
res.Entity = _rep.LogCount(type, LogActionType.Watch, start, end);
break;
default:
res.Success = false;
res.Message = "This log type isn't supported!";
break;
}
}
catch (Exception e)
{
res.Success = false;
res.Message = e.ToString();
}
return(res);
}
public ActionResult Musics(MusicReportViewModel model)
{
EntityResponse <int> res = new EntityResponse <int>();
model.EndDate = model.EndDate.HasValue ? model.EndDate.Value.AddDays(1) : DateTime.Now.AddDays(1);
model.StartDate = model.StartDate.HasValue ? model.StartDate : DateTime.Now.AddDays(-7);
switch (model.Type)
{
case MusicReportType.All:
res = musicService.GetMusicCount(null, null);
break;
case MusicReportType.Show:
res = service.GetLogsCountForEntityAction(EntityType.Music, LogType.MusicView, model.StartDate, model.EndDate);
break;
case MusicReportType.Purchase:
res = service.GetLogsCountForEntityAction(EntityType.Music, LogType.Purchase, model.StartDate, model.EndDate);
break;
}
model.EndDate = model.EndDate.Value.AddDays(-1);
if (!res.Success)
{
ModelState.AddModelError("", "נכשלה הבאת כמות היצירות!");
}
else
{
model.Count = res.Entity;
}
return(View(model));
}
public async Task <EntityResponse <ContactDto> > CreateContactAsync(AddContactDto newContactDto)
{
var result = ModelValidator.ValidateAsEntityValidation(newContactDto, "E0001").As <ContactDto>();
if (!result.Ok)
{
return(result);
}
bool alreadyExists = _contactRepository.AsQueryable().Any(e => e.Email == newContactDto.Email);
if (alreadyExists)
{
return(EntityResponse.CreateError("The email already exists.", "E0004").As <ContactDto>());
}
Contact contact = newContactDto.CreateEntity();
await _contactRepository.AddAsync(contact);
await unitOfWork.SaveChangesAsync();
ContactDto dto = new ContactDto
{
Email = contact.Email,
Id = contact.Id,
Name = contact.Name
};
return(EntityResponse.CreateOk().As(dto));
}
public EntityResponse <Tag> GetNewInSystemTag()
{
EntityResponse <Tag> res = new EntityResponse <Tag>();
try
{
res.Entity = this._rep.GetNewInSystemTag();
if (res.Entity == null)
{
res.Success = false;
res.Message = "התיוג חדש במערכת לא נמצא";
}
else
{
res.Success = true;
}
}
catch (Exception e)
{
res.Success = false;
res.Message = e.Message;
}
return(res);
}
public async Task Campaign_Create_CreateCampaignAndAddJobIdToEvents()
{
var appService = BuildAppService();
var newCampaignDto = new AddCampaignDto()
{
Name = "New 123",
EmailTemplateId = 1,
Events = new List <AddEventDto>
{
new AddEventDto
{
Date = DateTime.Now.AddDays(5)
},
new AddEventDto
{
Date = DateTime.Now.AddDays(8)
}
},
ContactLists = new List <int>
{
1
}
};
EntityResponse <CampaignDto> result = await appService.CreateCampaignAsync(newCampaignDto);
Assert.AreEqual(expected: true, result.Ok);
foreach (var item in result.Data.Events)
{
Assert.AreEqual(expected: false, string.IsNullOrWhiteSpace(item.ScheduleJobId));
}
}
public EntityResponse <string> GetPurchaseHTML(int musicID, PaskolUser buyer, int cost, string reference, string permission)
{
var res = new EntityResponse <string>();
try
{
Music music = _musicRep.GetByID(musicID);
res.Entity =
_pdfService.GetTempPurchaseHtml(
DateTime.Now,
buyer.UserName,
buyer.Email,
music.HebrewName,
music.MusicWriter,
music.MusicComposer,
music.MusicPerformer,
permission,
cost,
reference,
music.Exceptions);
res.Success = true;
}
catch (Exception e)
{
res.Success = false;
res.Message = e.ToString();
}
return(res);
}
private ResponseFields GetResponseFields(EntityResponse value)
{
ResponseFields result = new ResponseFields();
value.section.ForEach(s => result.Entities.Add(GetEntity(s)));
return(result);
}
public async Task Campaign_Create_CreateCampaignAndAddContactList()
{
var appService = BuildAppService();
var newCampaignDto = new AddCampaignDto()
{
Name = "New 123",
EmailTemplateId = 1,
Events = new List <AddEventDto>
{
new AddEventDto
{
Date = DateTime.Now.AddDays(5)
}
},
ContactLists = new List <int>
{
1
}
};
EntityResponse <CampaignDto> result = await appService.CreateCampaignAsync(newCampaignDto);
Assert.AreEqual(expected: true, result.Ok);
Assert.AreEqual(expected: 1, result.Data.ContactLists.Count);
Assert.AreEqual(expected: newCampaignDto.Name, result.Data.Name);
Assert.AreEqual(expected: 1, result.Data.Events.Count);
Assert.AreEqual(expected: newCampaignDto.Events.First().Date.Date, result.Data.Events.First().Date);
Assert.AreEqual(expected: newCampaignDto.Events.First().Date, result.Data.Events.First().Hour);
}
public string GetAuction(string id)
{
EntityResponse <AuctionRequirmentsViewModel> res =
new EntityResponse <AuctionRequirmentsViewModel>();
res.Success = false;
var AuctionResponse = _actionSrv.GetByID(id);
// if artist is participate with this auction
if (AuctionResponse?.Entity?.Participants?.Any(p => p.Id == User.Identity.GetUserId()) == true)
{
res.Success = true;
res.Entity = new AuctionRequirmentsViewModel()
{
AuctionId = AuctionResponse.Entity.AuctionId,
Budget = AuctionResponse.Entity.AuctionBudget,
ContactMan = AuctionResponse.Entity.ContactName,
Email = AuctionResponse.Entity.ContactEmail,
MusicLength = AuctionResponse.Entity.MusicLength,
Notes = AuctionResponse.Entity.Notes,
Using = AuctionResponse.Entity.UsingName,
Phone = AuctionResponse.Entity.ContactPhone,
Open = AuctionResponse.Entity.OpenDate.Value.ToString("yyyy/MM/dd"),
End = AuctionResponse.Entity.CloseDate.Value.ToString("yyyy/MM/dd"),
MusicProperties = AuctionResponse.Entity.MusicProperties
};
}
return(JsonConvert.SerializeObject(res));
}
public async Task <EntityResponse <Product> > Handle(GetProductsByNameQuery request, CancellationToken cancellationToken)
{
var response = new EntityResponse <Product> ()
{
ReponseName = nameof(GetProductsByNameQuery), Content = new List <Product> ()
{
}
};
var entities = await _productRepository.GetListAsync(
p => (p.Name == request.productName) && (p.UnitPrice != 0));
_mapper.Map <List <Product> > (entities);
if (entities == null)
{
response.Status = ResponseType.Warning;
response.Message = $"No {nameof(Product)}s were found.";
response.Content = null;
}
else
{
response.Status = ResponseType.Success;
response.Message = $"{nameof(Product)}s get successfully.";
response.Content.AddRange(entities);
}
return(response);
}
/// <summary>
/// Get ConfigSection by Id or All Root Sections
/// </summary>
public EntityResponse <IQueryable <ConfigDirectory> > GetConfigDirectoryById(long?id)
{
IQueryable <ConfigDirectory> configSectionQueryable;
if (id.HasValue)
{
ConfigDirectory configSection = Uow.ConfigDirectories.GetById(id.Value);
if (configSection == null)
{
return(ErrorCode.ConfigurationSectionNotFound);
}
configSectionQueryable = (new List <ConfigDirectory> {
configSection
}).AsQueryable();
}
else
{
configSectionQueryable = Uow.ConfigDirectories.GetAllRoots();
}
EntityResponse <IQueryable <ConfigDirectory> > result = EntityResponse <IQueryable <ConfigDirectory> > .Success(configSectionQueryable);
return(result);
}
public async Task <EntityResponse <MoneyApproval> > Handle(GetListMoneyApprovalQuery request, CancellationToken cancellationToken)
{
var response = new EntityResponse <MoneyApproval> ()
{
ReponseName = nameof(GetListMoneyApprovalQuery), Content = new List <MoneyApproval> ()
{
}
};
var entities = await _approvalRepository.GetAllAsync();
_mapper.Map <List <MoneyApproval> > (entities);
if (entities == null)
{
response.Status = ResponseType.Warning;
response.Message = $"No {nameof(MoneyApproval)}s were found.";
response.Content = null;
}
else
{
response.Status = ResponseType.Success;
response.Message = $"{nameof(MoneyApproval)}s get successfully.";
response.Content.AddRange(entities);
}
return(response);
}
public override Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content,
TransportContext transportContext)
{
EntityResponse entityResponse = value as EntityResponse;
if (entityResponse != null)
{
return(base.WriteToStreamAsync(
entityResponse.Entity.GetType(),
entityResponse.Entity,
writeStream,
content,
transportContext));
}
IEnumerable <EntityResponse> responses = value as IEnumerable <EntityResponse>;
if (responses != null)
{
List <object> result = responses.Select(response => !response.IsSuccess
? response as object
: response.Entity).ToList();
return(base.WriteToStreamAsync(result.GetType(), result, writeStream, content, transportContext));
}
return(base.WriteToStreamAsync(type, value, writeStream, content, transportContext));
}
public EntityResponse CreateEntity(string workspaceId, CreateEntity body)
{
if (string.IsNullOrEmpty(workspaceId))
{
throw new ArgumentNullException(nameof(workspaceId));
}
if (body == null)
{
throw new ArgumentNullException(nameof(body));
}
if (string.IsNullOrEmpty(VersionDate))
{
throw new ArgumentNullException("versionDate cannot be null. Use 'CONVERSATION_VERSION_DATE_2017_05_26'");
}
EntityResponse result = null;
try
{
result = this.Client.WithAuthentication(this.UserName, this.Password)
.PostAsync($"{this.Endpoint}/v1/workspaces/{workspaceId}/entities")
.WithArgument("version", VersionDate)
.WithBody <CreateEntity>(body)
.As <EntityResponse>()
.Result;
}
catch (AggregateException ae)
{
throw ae.Flatten();
}
return(result);
}
public async Task <EntityResponse <User> > Handle(GetUserQuery request, CancellationToken cancellationToken)
{
var response = new EntityResponse <User> ()
{
ReponseName = nameof(GetUserQuery), Content = new List <User> ()
{
}
};
var user = await _userRepository.GetOneAsync(p => p.Id == request.Id);
user = _mapper.Map <User> (user);
if (user == null)
{
response.Status = ResponseType.Error;
response.Message = $"{nameof(User)} not found.";
response.Content = null;
}
else
{
response.Status = ResponseType.Success;
response.Message = $"{nameof(User)} get successfully.";
response.Content.Add(user);
}
return(response);
}
public async Task <EntityResponse <ProductApproval> > Handle(CreateProductApprovalCommand request, CancellationToken cancellationToken)
{
var response = new EntityResponse <ProductApproval> ()
{
ReponseName = nameof(CreateProductApprovalCommand), Content = new List <ProductApproval> ()
{
}
};
var entity = _mapper.Map <ProductApproval> (request);
var newentity = await _approvalRepository.AddAsync(entity);
if (newentity == null)
{
response.Status = ResponseType.Warning;
response.Message = $"{nameof(ProductApproval)} could not be created.";
response.Content = null;
}
else
{
response.Status = ResponseType.Success;
response.Message = $"{nameof(ProductApproval)} created successfully.";
response.Content.Add(newentity);
}
return(response);
}
public EntityResponse<User> Login(LoginRequest credentials)
{
var response = new EntityResponse<User> {EntityType = typeof (User).ToString()};
// set up domain context
var ctx = new PrincipalContext(ContextType.Domain);
if (ctx.ValidateCredentials(credentials.UserName, credentials.Password))
{
var user = UserPrincipal.FindByIdentity(ctx, credentials.UserName);
if (user != null)
{
var u = new User
{
Email = user.EmailAddress,
DisplayName = user.DisplayName,
UserName = credentials.UserName
};
response.ResponseCode = ResponseCode.Success;
response.Message = ResponseMessage.Success;
response.Data = u;
}
else
{
SetResponseError(ref response);
}
}
else
SetResponseError(ref response);
return response;
}
protected virtual void SetMissingRevFromResponseHeaders <T>(EntityResponse <T> response, HttpResponseHeaders responseHeaders) where T : class
{
if (string.IsNullOrWhiteSpace(response.Rev))
{
response.Rev = responseHeaders.GetETag();
}
}
public async Task <EntityResponse <Product> > Handle(GetProductsUserQuery request, CancellationToken cancellationToken)
{
var response = new EntityResponse <Product> ()
{
ReponseName = nameof(GetProductsUserQuery), Content = new List <Product> ()
{
}
};
var entities = new List <Product> ();
foreach (var item in request.productIds)
{
entities.Add(await _productRepository.GetAsync(p => (p.Id == item)));
}
_mapper.Map <List <Product> > (entities);
if (entities == null)
{
response.Status = ResponseType.Warning;
response.Message = $"No {nameof(Product)}s were found.";
response.Content = null;
}
else
{
response.Status = ResponseType.Success;
response.Message = $"{nameof(Product)}s get successfully.";
response.Content.AddRange(entities);
}
return(response);
}
public async Task <EntityResponse <Report> > Handle(GetReportsListQuery request, CancellationToken cancellationToken)
{
var response = new EntityResponse <Report> ()
{
ReponseName = nameof(GetReportsListQuery), Content = new List <Report> ()
{
}
};
var ReportList = await _reportRepository.GetAllAsync();
_mapper.Map <List <Report> > (ReportList);
if (ReportList == null)
{
response.Status = ResponseType.Error;
response.Message = $"No {nameof(Report)}s were found .";
response.Content = null;
}
else
{
response.Status = ResponseType.Success;
response.Message = $"{nameof(Report)}s get successfully.";
response.Content.AddRange(ReportList);
}
return(response);
}
protected virtual void SetMissingIdFromRequestUri <T>(EntityResponse <T> response, HttpRequestMessage request) where T : class
{
if (string.IsNullOrWhiteSpace(response.Id) && request.Method != HttpMethod.Post)
{
response.Id = request.ExtractIdFromUri(false);
}
}
public async Task <ActionResult <TEditEntityDto> > Post([FromBody] TCreateEntityDto entityDto, [FromServices] RemboardContext context, [FromServices] IAuthorizationService authorizationService, [FromServices] CrudResourcePointControllerFactory <TEntity, TCreateEntityDto, TEditEntityDto, TFilterableEntity, TKey> controllerFactory)
{
var result = await authorizationService.AuthorizeAsync(User, typeof(TEntity), CrudOperations.Create);
if (!result.Succeeded)
{
return(Forbid());
}
var validator = controllerFactory.GetCreateDtoValidator();
var validationResult = await ValidateAsync(validator, entityDto);
if (validationResult == null)
{
var operation = controllerFactory.GetCrudOperation();
var correctors = controllerFactory.GetCorrectors();
var saved = await operation.Post(entityDto, context, correctors);
var producers = controllerFactory.GetAfterEntityCreateCommandProducersOrNull();
await producers.SendToAll(entityDto, saved.entity.Id);
return(Ok(saved.entityDto));
}
var errorResponse = new EntityResponse
{
Message = "Failed to save entity",
};
errorResponse.ValidationErrors.AddRange(validationResult);
return(BadRequest(errorResponse));
}
public virtual async void Materialize <T>(EntityResponse <T> response, HttpResponseMessage httpResponse) where T : class
{
using (var content = await httpResponse.Content.ReadAsStreamAsync().ForAwait())
{
var get = response as GetEntityResponse <T>;
if (get != null)
{
response.Content = Serializer.DeserializeCopied <T>(content);
response.Id = EntityReflector.IdMember.GetValueFrom(response.Content);
response.Rev = EntityReflector.RevMember.GetValueFrom(response.Content);
var tmp = Serializer.Deserialize <Temp>(content);
get.Conflicts = tmp._conflicts;
get.Id = get.Id ?? tmp.Id;
get.Rev = get.Rev ?? tmp.Rev;
}
else
{
Serializer.Populate(response, content);
}
SetMissingIdFromRequestUri(response, httpResponse.RequestMessage);
SetMissingRevFromRequestHeaders(response, httpResponse.Headers);
}
}
public IActionResult ClearItems(Guid orderId)
{
var response = new EntityResponse <Order>(null, "");
if (orderId == Guid.Empty)
{
response.Message = "ClearItems: orderId is invalid";
return(BadRequest(response));
}
var order = _orderRepository.Get(orderId);
if (order == null)
{
response.Message = "ClearItems: order not found";
return(BadRequest(response));
}
order.Items.Clear();
if (_orderRepository.Update(order))
{
response.Entity = order;
response.Message = "OK";
return(Ok(response));
}
response.Message = "ClearItems: items could not be deleted";
return(StatusCode((int)HttpStatusCode.InternalServerError, response));
}
public IActionResult AddItemToOrder(Guid orderId, [FromBody] Item item)
{
var response = new EntityResponse <Order>(null, "");
var order = _orderRepository.Get(orderId);
if (order == null)
{
response.Message = "AddItemToOrder: order not found";
return(BadRequest(response));
}
order.Items.Add(item);
if (_orderRepository.Update(order))
{
response.Entity = order;
response.Message = "OK";
return(Ok(response));
}
response.Message = "AddItemToOrder: item could not be added to order";
return(StatusCode((int)HttpStatusCode.InternalServerError, response));
}
public EntityResponse <AuthenticationModel> SignIn(SignInModel signInModel)
{
if (!ModelState.IsValid)
{
List <string> errorMessages = GetValidationErrorMessages();
EntityResponse <AuthenticationModel> error =
EntityResponse <AuthenticationModel> .Error(ErrorCode.AccountVerificationInvalidModel, string.Join(".", errorMessages));
return(error);
}
Role role = _authenticationService.Authenticate(signInModel.Login, signInModel.Password, signInModel.LoginAccountType, signInModel.RememberMe);
if (role == null)
{
EntityResponse <AuthenticationModel> error = EntityResponse <AuthenticationModel> .Error(
ErrorCode.AccountVerificationInvalidLoginOrPassword,
ClientErrorMessages.AccountController_AccountVerificationInvalidLoginOrPassword);
return(error);
}
AuthenticationModel authenticationModel = GetSecurityModel();
return(authenticationModel);
}
public async Task <EntityResponse <ProductApproval> > Handle(UpdateProductApprovalCommand request, CancellationToken cancellationToken)
{
var response = new EntityResponse <ProductApproval> ()
{
ReponseName = nameof(UpdateProductApprovalCommand), Content = new List <ProductApproval> ()
{
}
};
var entity = await _approvalRepository.GetOneAsync(p => p.Id == request.Id);
if (entity == null)
{
response.Status = ResponseType.Warning;
response.Message = $"{nameof(ProductApproval)} not found.";
response.Content = null;
}
else
{
_mapper.Map(request, entity, typeof(UpdateProductApprovalCommand), typeof(ProductApproval));
await _approvalRepository.UpdateAsync(entity);
response.Status = ResponseType.Success;
response.Message = $"{nameof(ProductApproval)} updated successfully.";
response.Content.Add(entity);
}
return(response);
}
/// <summary>
/// Authenticates user in the system.
/// </summary>
/// <param name="loginName">login name</param>
/// <param name="password">password</param>
/// <param name="rememberMe">remember user or not</param>
/// <returns><c>true</c> entity if authenticated, otherwise - <c>false</c></returns>
public Role Authenticate(string loginName, string password, string loginAccountType, bool rememberMe = false)
{
User user = Uow.Users.GetByLoginName(loginName);
if (user == null)
{
EntityResponse <UserLoginInformation> loginInfo =
_accountManager.UserLogin(
loginAccountType == "U" ? LoginAccountType.CustomerCode : LoginAccountType.CustomerAccountCode,
loginName,
password,
PasswordUseScope.OptionTrade);
if (loginInfo.IsSuccess)
{
EntityResponse <FCUser> fcUserResponse = _userService.AddOrUpdateFCUser(loginInfo.Entity, password);
user = fcUserResponse.Entity;
}
}
if (user != null)
{
return(Authenticate(user, password, rememberMe));
}
Logger.Warn(string.Format("Invalid user name {0}", loginName));
return(null);
}
public EntityResponse <List <HistoricalOptionTradeInformation> > GetHistoricalOptionTrades(HistoricalOptionOrdersArguments historicalOrderArguments)
{
List <SZKingdomArgument> arguments = new List <SZKingdomArgument>();
if (historicalOrderArguments.CustomerCode == null && historicalOrderArguments.CustomerAccountCode == null)
{
EntityResponse <List <HistoricalOptionTradeInformation> > entityResponse = EntityResponse <List <HistoricalOptionTradeInformation> >
.Error(ErrorCode.SZKingdomLibraryError, SameCodesErrorMessage);
return(entityResponse);
}
arguments.Add(SZKingdomArgument.CustomerCode(historicalOrderArguments.CustomerCode));
arguments.Add(SZKingdomArgument.CustomerAccountCode(historicalOrderArguments.CustomerAccountCode));
arguments.Add(SZKingdomArgument.StockBoard(historicalOrderArguments.StockBoard));
arguments.Add(SZKingdomArgument.TradeAccount(historicalOrderArguments.TradeAccount));
arguments.Add(SZKingdomArgument.OptionNumber(historicalOrderArguments.OptionNumber));
arguments.Add(SZKingdomArgument.OptionUnderlyingCode(historicalOrderArguments.OptionUnderlyingCode));
arguments.Add(SZKingdomArgument.OrderId(historicalOrderArguments.OrderId));
arguments.Add(SZKingdomArgument.OrderBatchSerialNo(historicalOrderArguments.OrderBatchSerialNo));
arguments.Add(SZKingdomArgument.BeginDate(historicalOrderArguments.BeginDate.ToString(SZKingdomMappingHelper.SZKingdomDateFormat)));
arguments.Add(SZKingdomArgument.EndDate(historicalOrderArguments.EndDate.ToString(SZKingdomMappingHelper.SZKingdomDateFormat)));
arguments.Add(SZKingdomArgument.PageNumber(historicalOrderArguments.PageNumber));
arguments.Add(SZKingdomArgument.PageRecordCount(historicalOrderArguments.PageRecordCount));
EntityResponse <List <HistoricalOptionTradeInformation> > result = _marketDataLibrary
.ExecuteCommandList <HistoricalOptionTradeInformation>(SZKingdomRequest.HistoricalOptionTrades, arguments);
return(result);
}
public EntityResponse <List <IntradayOptionOrderBasicInformation> > GetCancellableOrders(IntradayOptionOrderArguments intradayOrderArguments)
{
List <SZKingdomArgument> arguments = new List <SZKingdomArgument>();
if (intradayOrderArguments.CustomerCode == null && intradayOrderArguments.CustomerAccountCode == null)
{
EntityResponse <List <IntradayOptionOrderBasicInformation> > entityRespose = EntityResponse <List <IntradayOptionOrderBasicInformation> >
.Error(ErrorCode.SZKingdomLibraryError, SameCodesErrorMessage);
return(entityRespose);
}
arguments.Add(SZKingdomArgument.CustomerCode(intradayOrderArguments.CustomerCode));
arguments.Add(SZKingdomArgument.CustomerAccountCode(intradayOrderArguments.CustomerAccountCode));
arguments.Add(SZKingdomArgument.StockBoard(intradayOrderArguments.StockBoard));
arguments.Add(SZKingdomArgument.TradeAccount(intradayOrderArguments.TradeAccount));
arguments.Add(SZKingdomArgument.OptionNumber(intradayOrderArguments.OptionNumber));
arguments.Add(SZKingdomArgument.OptionUnderlyingCode(intradayOrderArguments.OptionUnderlyingCode));
arguments.Add(SZKingdomArgument.OrderId(intradayOrderArguments.OrderId));
arguments.Add(SZKingdomArgument.QueryPosition(intradayOrderArguments.QueryPosition));
EntityResponse <List <IntradayOptionOrderBasicInformation> > result = _marketDataLibrary
.ExecuteCommandList <IntradayOptionOrderBasicInformation>(SZKingdomRequest.CancelableOptionOrders, arguments);
return(result);
}
public async Task <EntityResponse <ProductApproval> > Handle(GetProductApprovalQuery request, CancellationToken cancellationToken)
{
var response = new EntityResponse <ProductApproval> ()
{
ReponseName = nameof(GetProductApprovalQuery), Content = new List <ProductApproval> ()
{
}
};
var entity = await _approvalRepository.GetOneAsync(p => p.Id == request.Id);
entity = _mapper.Map <ProductApproval> (entity);;
if (entity == null)
{
response.Status = ResponseType.Warning;
response.Message = $"{nameof(ProductApproval)} not found.";
response.Content = null;
}
else
{
response.Status = ResponseType.Success;
response.Message = $"{nameof(ProductApproval)} get successfully.";
response.Content.Add(entity);
}
return(response);
}
private void SetResponseError(ref EntityResponse<User> response)
{
response.Message = "Invalid UserName and/or Password!";
response.ResponseCode = ResponseCode.Fail;
}
