Пример #1
0
 public ExtensionService(AccountToService serviceCopy)
 {
     this.Id     = serviceCopy.PKId;
     this.Name   = serviceCopy.Name;
     this.Amount = serviceCopy.Amount1;
     this.Status = serviceCopy.Status.ToString();
     this.StatusLastChangedDate = serviceCopy.StatusDate;
     this.AuthorizationLevel    = serviceCopy.AuthorizationLevel.ToString();
     this.StartDate             = serviceCopy.StartDate;
     this.EndDate         = serviceCopy.EndDate;
     this.LastChangedDate = serviceCopy.LastChangedDate;
     this.IsOwner         = serviceCopy.IsOwner;
     this.AccountId       = serviceCopy.AccountId;
     this.ServiceId       = serviceCopy.ServiceId;
     //base table (service being subscribed to or owned)
     this.Label          = serviceCopy.Service.ServiceNum;
     this.ServiceName    = serviceCopy.Service.ServiceName;
     this.Description    = serviceCopy.Service.ServiceDesc;
     this.Price          = serviceCopy.Service.ServicePrice1;
     this.Unit           = serviceCopy.Service.ServiceUnit1;
     this.ServiceGroupId = serviceCopy.Service.ServiceClassId;
     this.NetworkId      = serviceCopy.Service.NetworkId;
     this.OwningClubId   = serviceCopy.OwningClubId;
     this.MiscDocPath    = string.Empty;
 }
Пример #2
0
        public static AccountToService GetService(ExtensionService serviceCopy)
        {
            AccountToService newService = new AccountToService();

            newService.PKId    = serviceCopy.Id;
            newService.Name    = serviceCopy.Name;
            newService.Amount1 = serviceCopy.Amount;
            newService.Status
                = Data.AppHelpers.Agreement.SERVICE_STATUS_TYPES.current.ToString();
            newService.StatusDate = serviceCopy.StatusLastChangedDate;
            newService.AuthorizationLevel
                = (int)AccountHelper.AUTHORIZATION_LEVELS.none;
            newService.StartDate       = serviceCopy.StartDate;
            newService.EndDate         = serviceCopy.EndDate;
            newService.LastChangedDate = serviceCopy.LastChangedDate;
            newService.IsOwner         = serviceCopy.IsOwner;
            newService.AccountId       = serviceCopy.AccountId;
            newService.ServiceId       = serviceCopy.ServiceId;
            //base table (service being subscribed to or owned)
            newService.Service.ServiceNum     = serviceCopy.Label;
            newService.Service.ServiceName    = serviceCopy.ServiceName;
            newService.Service.ServiceDesc    = serviceCopy.Description;
            newService.Service.ServicePrice1  = serviceCopy.Price;
            newService.Service.ServiceUnit1   = serviceCopy.Unit;
            newService.Service.ServiceClassId = serviceCopy.ServiceGroupId;
            newService.Service.NetworkId      = serviceCopy.NetworkId;
            newService.OwningClubId           = serviceCopy.OwningClubId;
            //newService.Service.MiscDocPath = string.Empty;
            return(newService);
        }
Пример #3
0
        public async Task <List <AccountToService> > GetServiceByServiceIdAsync(
            ContentURI uri, int serviceId, bool isOwner)
        {
            List <AccountToService> colClubService = new List <AccountToService>();

            if (serviceId == 0)
            {
                //set default objects
                AccountToService atos = new AccountToService(true);
                colClubService.Add(atos);
                return(colClubService);
            }
            int iIsOwner = (isOwner) ? 1 : 0;

            Helpers.SqlIOAsync sqlIO    = new Helpers.SqlIOAsync(uri);
            SqlParameter[]     colPrams =
            {
                sqlIO.MakeInParam("@ServiceId", SqlDbType.Int, 4, serviceId),
                sqlIO.MakeInParam("@IsOwner",   SqlDbType.Bit, 1, iIsOwner)
            };
            //this sp must also run a subquery that sets the owning club id
            SqlDataReader dataReader = await sqlIO.RunProcAsync(
                "0GetServicesByServiceId", colPrams);

            colClubService = FillClubServiceList(dataReader);
            sqlIO.Dispose();
            return(colClubService);
        }
Пример #4
0
        public List <AccountToService> FillClubServiceList(SqlDataReader services)
        {
            List <AccountToService> colService = new List <AccountToService>();

            if (services != null)
            {
                using (services)
                {
                    //build a related service list to return to the client
                    while (services.Read())
                    {
                        AccountToService newService = new AccountToService();
                        newService.Service = new Service();

                        newService.PKId               = services.GetInt32(0);
                        newService.Name               = services.GetString(1);
                        newService.Amount1            = services.GetInt32(2);
                        newService.Status             = services.GetString(3);
                        newService.LastChangedDate    = services.GetDateTime(4);
                        newService.AuthorizationLevel = services.GetInt16(5);
                        newService.StartDate          = services.GetDateTime(6);
                        newService.EndDate            = services.GetDateTime(7);
                        newService.LastChangedDate    = services.GetDateTime(8);
                        newService.IsOwner            = services.GetBoolean(9);
                        newService.AccountId          = services.GetInt32(10);
                        newService.ServiceId          = services.GetInt32(11);
                        //base table (service being subscribed to or owned)
                        newService.Service                  = new Service();
                        newService.Service.ServiceNum       = services.GetString(12);
                        newService.Service.ServiceName      = services.GetString(13);
                        newService.Service.ServiceDesc      = services.GetString(14);
                        newService.Service.ServicePrice1    = services.GetDecimal(15);
                        newService.Service.ServiceUnit1     = services.GetString(16);
                        newService.Service.ServiceClassId   = services.GetInt32(17);
                        newService.Service.NetworkId        = services.GetInt32(18);
                        newService.OwningClubId             = services.GetInt32(19);
                        newService.Service.ServiceCurrency1 = services.GetString(20);
                        newService.Account                  = new Account();
                        newService.Account.PKId             = services.GetInt32(21);
                        newService.Account.AccountName      = services.GetString(22);
                        newService.Account.AccountDesc      = services.GetString(23);
                        newService.Account.AccountLongDesc  = services.GetString(24);
                        newService.Account.AccountEmail     = services.GetString(25);
                        newService.Account.AccountURI       = services.GetString(26);
                        newService.Account.AccountClassId   = services.GetInt32(27);
                        newService.Account.GeoRegionId      = services.GetInt32(28);
                        //not in db
                        newService.Account.ClubDocFullPath = string.Empty;
                        newService.Account.PrivateAuthorizationLevel
                            = AccountHelper.AUTHORIZATION_LEVELS.none;
                        newService.Account.NetCost   = 0;
                        newService.Account.TotalCost = 0;
                        newService.Account.URIFull   = string.Empty;
                        colService.Add(newService);
                    }
                }
            }
            return(colService);
        }
Пример #5
0
 //deprecated in 2.0.0 in favor of uniform EF form edits
 //public async Task<bool> UpdateDefaultClubAsync(ContentURI uri, string editAttName,
 //    int id)
 //{
 //    bool bIsUpdated = false;
 //    int iAuthorizationLevel = (int)AccountHelper.AUTHORIZATION_LEVELS.viewonly;
 //    int iAccountId = 0;
 //    try
 //    {
 //        //update the database and db model
 //        IList<AccountToMember> members = await _dataContext.AccountToMember
 //                .Where(cm => cm.MemberId == uri.URIMember.MemberId)
 //                .ToListAsync();
 //        //execute the query, and make edit changes
 //        bool bIsDefaultClub = false;
 //        if (members != null)
 //        {
 //            foreach (AccountToMember cm in members)
 //            {
 //                bIsDefaultClub = false;
 //                AccountToMember existingAM = await _dataContext.AccountToMember.SingleOrDefaultAsync(x => x.PKId == cm.PKId);
 //                if (existingAM != null)
 //                {
 //                    //tell the tracker to change the state is unchanged
 //                    _dataContext.Entry(existingAM).State = EntityState.Unchanged;
 //                    if (cm.AccountId == id)
 //                    {
 //                        if (editAttName == AppHelpers.Members.ISDEFAULTCLUB)
 //                        {
 //                            bIsDefaultClub = true;
 //                            existingAM.IsDefaultClub = bIsDefaultClub;
 //                            //don't set these to null or changes uri
 //                            //existingAM.ClubDefault = null;
 //                            //existingAM.Member = null;
 //                        }
 //                    }
 //                    else
 //                    {
 //                        existingAM.IsDefaultClub = bIsDefaultClub;
 //                        existingAM.ClubDefault = null;
 //                        existingAM.Member = null;
 //                    }
 //                    _dataContext.Entry(existingAM).State = EntityState.Modified;
 //                }
 //            }
 //            await _dataContext.SaveChangesAsync();
 //            bIsUpdated = true;
 //            UpdateListsAsync(uri, iAccountId, iAuthorizationLevel, id);
 //        }
 //    }
 //    catch (Exception e)
 //    {
 //        uri.ErrorMessage = DevTreks.Exceptions.DevTreksErrors.MakeStandardErrorMsg(
 //            e.InnerException.ToString(), "ERROR_INTRO");
 //    }
 //    return bIsUpdated;
 //}
 private void UpdateListsAsync(ContentURI uri, int accountId, int authorizationLevel,
                               int id)
 {
     if (uri.URIDataManager.AppType
         == Helpers.GeneralHelpers.APPLICATION_TYPES.agreements)
     {
         //update the DevTreks model
         if (uri.URIService != null)
         {
             if (uri.URIService.Service != null)
             {
                 if (uri.URIService.Service.SubscribedClubs != null)
                 {
                     if (uri.URIService.Service.SubscribedClubs.Count > 0)
                     {
                         AccountToService oSubscribedClub
                             = uri.URIService.Service.SubscribedClubs.FirstOrDefault(
                                   c => c.PKId == id);
                         if (oSubscribedClub != null)
                         {
                             oSubscribedClub.AuthorizationLevel
                                 = (short)authorizationLevel;
                         }
                     }
                 }
             }
         }
     }
     else if (uri.URIDataManager.AppType
              == Helpers.GeneralHelpers.APPLICATION_TYPES.members)
     {
         if (uri.URIMember.Member != null)
         {
             if (uri.URIMember.Member.AccountToMember != null)
             {
                 foreach (AccountToMember memberClub in uri.URIMember.Member.AccountToMember)
                 {
                     if (memberClub.AccountId == id)
                     {
                         memberClub.IsDefaultClub = true;
                     }
                     else
                     {
                         memberClub.IsDefaultClub = false;
                     }
                 }
             }
         }
     }
 }
Пример #6
0
        private bool UpdateSubscribedServiceMemberCount(ContentURI agreementURI,
                                                        AccountToService accountService, bool isOwner, int currentClubMemberCount,
                                                        int memberCount)
        {
            bool bHasUpdated = false;

            if (!isOwner)
            {
                AppHelpers.Agreement aggreement = new Agreement();
                //bHasUpdated = aggreement.UpdateSubscribedMemberCount(agreementURI, currentClubMemberCount,
                //    accountService.AccountId, accountService.PKId, memberCount);
            }
            return(bHasUpdated);
        }
Пример #7
0
        public async Task <bool> UpdateSubscribedMemberCountAsync(ContentURI uri,
                                                                  int currentClubMemberCount, int accountId, int joinServiceId,
                                                                  int memberCount)
        {
            //service agreement revenues are derived from subscribing clubs member count
            //(fees are charged per club member)
            bool bHasUpdated = false;

            if (uri.URIMember.ClubInUse != null &&
                uri.URIMember.ClubDefault != null &&
                joinServiceId != 0 && accountId != 0)
            {
                if (uri.URIMember.ClubInUse.PrivateAuthorizationLevel
                    == AccountHelper.AUTHORIZATION_LEVELS.fulledits &&
                    uri.URIMember.ClubDefault.PKId == accountId)
                {
                    if (currentClubMemberCount != memberCount)
                    {
                        //update the database and db model
                        try
                        {
                            //update the database and db model
                            AccountToService existingAC =
                                await _dataContext.AccountToService.SingleOrDefaultAsync(x => x.PKId == joinServiceId);

                            if (existingAC != null)
                            {
                                //tell the tracker to change the state is unchanged
                                _dataContext.Entry(existingAC).State = EntityState.Unchanged;
                                //execute the query, and make edit changes
                                existingAC.Amount1                   = currentClubMemberCount;
                                existingAC.LastChangedDate           = Helpers.GeneralHelpers.GetDateShortNow();
                                _dataContext.Entry(existingAC).State = EntityState.Modified;
                                //state is now modified and can be updated
                                await _dataContext.SaveChangesAsync();

                                bHasUpdated = true;
                            }
                        }
                        catch (Exception e)
                        {
                            uri.ErrorMessage = DevTreks.Exceptions.DevTreksErrors.MakeStandardErrorMsg(
                                e.InnerException.ToString(), "MEMBERREPOSIT_UPcDateAGREEMENTAMOUNT");
                        }
                    }
                }
            }
            return(bHasUpdated);
        }
Пример #8
0
        private void SetHostFee(ContentURI uri,
                                AccountToService accountservice, double totalServiceCost)
        {
            double dbHostFee = (double)accountservice.HostServiceFee;
            string sHostRate = uri.URIDataManager.HostFeeRate;

            if (string.IsNullOrEmpty(sHostRate))
            {
                sHostRate = "0";
            }
            double dbHostRate = Helpers.GeneralHelpers.ConvertStringToDouble(sHostRate);

            accountservice.HostServiceRate = dbHostRate;
            dbHostFee = (totalServiceCost * accountservice.HostServiceRate);
            accountservice.HostServiceFee = Math.Round((decimal)dbHostFee, 2);
        }
Пример #9
0
        public AccountToService FillServiceObject(SqlDataReader service)
        {
            //this is a one-record reader
            int i = 0;
            //avoid null refs with object props
            AccountToService newService = new AccountToService(true);

            if (service != null)
            {
                using (service)
                {
                    while (service.Read())
                    {
                        if (i == 0)
                        {
                            newService.PKId               = service.GetInt32(0);
                            newService.Name               = service.GetString(1);
                            newService.Amount1            = service.GetInt32(2);
                            newService.Status             = service.GetString(3);
                            newService.StatusDate         = service.GetDateTime(4);
                            newService.AuthorizationLevel = service.GetInt16(5);
                            newService.StartDate          = service.GetDateTime(6);
                            newService.EndDate            = service.GetDateTime(7);
                            newService.LastChangedDate    = service.GetDateTime(8);
                            newService.IsOwner            = service.GetBoolean(9);
                            newService.AccountId          = service.GetInt32(10);
                            newService.ServiceId          = service.GetInt32(11);
                            //base table (service being subscribed to or owned)
                            newService.Service                = new Service();
                            newService.Service.PKId           = newService.ServiceId;
                            newService.Service.ServiceNum     = service.GetString(12);
                            newService.Service.ServiceName    = service.GetString(13);
                            newService.Service.ServiceDesc    = service.GetString(14);
                            newService.Service.ServicePrice1  = service.GetDecimal(15);
                            newService.Service.ServiceUnit1   = service.GetString(16);
                            newService.Service.ServiceClassId = service.GetInt32(17);
                            //must switch uripatterns from now on to this networkid (on service layer)
                            newService.Service.NetworkId = service.GetInt32(18);
                            newService.OwningClubId      = service.GetInt32(19);
                        }
                        i++;
                    }
                }
            }
            return(newService);
        }
Пример #10
0
        private decimal GetMonthlyEquivalentTotals(AccountToService accountService)
        {
            decimal dTotalCost = accountService.Service.ServicePrice1 * accountService.Amount1;

            //convert costs to monthy basis for uniformity
            if (accountService.Service.ServiceUnit1 == Agreement.SERVICE_UNIT_TYPES.day.ToString())
            {
                dTotalCost = dTotalCost * 30;
            }
            else if (accountService.Service.ServiceUnit1 == Agreement.SERVICE_UNIT_TYPES.month.ToString())
            {
                //good total on hand
            }
            else if (accountService.Service.ServiceUnit1 == Agreement.SERVICE_UNIT_TYPES.year.ToString())
            {
                dTotalCost = dTotalCost / 12;
            }
            return(Math.Round(dTotalCost, 2));
        }
Пример #11
0
        public async Task <List <AccountToService> > GetRelatedServiceAsync(
            SearchManager searcher)
        {
            List <AccountToService> colService      = new List <AccountToService>();
            AccountToService        serviceSelected = new AccountToService(true);

            if (searcher.NetworkType
                != DevTreks.Data.AppHelpers.Networks.NETWORK_FILTER_TYPES.allnetworks &&
                searcher.NetworkSelected.PKId != 0)
            {
                colService = await _repository.GetRelatedServiceAsync(searcher);
            }
            serviceSelected = colService.FirstOrDefault(
                s => s.PKId == searcher.SearchResult.URIService.PKId);
            if (serviceSelected != null)
            {
                serviceSelected.IsSelected = true;
            }
            else
            {
                if (searcher.SearchResult.URIService != null)
                {
                    serviceSelected = searcher.SearchResult.URIService;
                }
                else
                {
                    if (colService.Count > 0)
                    {
                        serviceSelected = colService[0];
                    }
                }
                if (serviceSelected != null)
                {
                    serviceSelected.IsSelected = true;
                }
            }
            if (serviceSelected == null)
            {
                serviceSelected = new AccountToService(true);
            }
            searcher.ServiceSelected = serviceSelected;
            return(colService);
        }
Пример #12
0
        private async Task <bool> UpdateAuthorizationLevelAsync(ContentURI uri, string editAttName,
                                                                string editAttValue, int id)
        {
            bool bIsUpdated          = false;
            int  iAuthorizationLevel = (int)AccountHelper.AUTHORIZATION_LEVELS.viewonly;
            int  iAccountId          = 0;

            //submit the changes to the database.
            try
            {
                //update the database and db model
                AccountToService existingAC = await _dataContext.AccountToService.SingleOrDefaultAsync(x => x.PKId == id);

                if (existingAC != null)
                {
                    //tell the tracker to change the state is unchanged
                    _dataContext.Entry(existingAC).State = EntityState.Unchanged;
                    //execute the query, and make edit changes
                    if (editAttName.Contains(AppHelpers.Members.AUTHORIZATION_LEVEL))
                    {
                        iAuthorizationLevel
                            = Helpers.GeneralHelpers.ConvertStringToInt(editAttValue);
                        existingAC.AuthorizationLevel = (short)iAuthorizationLevel;
                        iAccountId         = existingAC.AccountId;
                        existingAC.Account = null;
                        existingAC.Service = null;
                        _dataContext.Entry(existingAC).State = EntityState.Modified;
                        //state is now modified and can be updated
                        await _dataContext.SaveChangesAsync();
                    }
                    bIsUpdated = true;
                    UpdateListsAsync(uri, iAccountId, iAuthorizationLevel, id);
                }
            }
            catch (Exception e)
            {
                uri.ErrorMessage = DevTreks.Exceptions.DevTreksErrors.MakeStandardErrorMsg(
                    e.InnerException.ToString(), "ERROR_INTRO");
            }
            return(bIsUpdated);
        }
Пример #13
0
        public async Task <List <AccountToMember> > GetClubByServiceAndMemberAsync(
            ContentURI uri, int serviceId, int memberId)
        {
            List <AccountToMember> clubs = new List <AccountToMember>();

            if (memberId == 0 ||
                serviceId == 0)
            {
                AccountToMember club = new AccountToMember(true);
                //return blank member and service if not a real member or a real service
                club.ClubDefault = new Account(true);
                club.Member      = new Member(true);
                clubs.Add(club);
                return(clubs);
            }
            Helpers.SqlIOAsync sqlIO    = new Helpers.SqlIOAsync(uri);
            SqlParameter[]     colPrams =
            {
                sqlIO.MakeInParam("@MemberId",  SqlDbType.Int, 4, memberId),
                sqlIO.MakeInParam("@ServiceId", SqlDbType.Int, 4, serviceId)
            };
            SqlDataReader dataReader = await sqlIO.RunProcAsync(
                "0GetClubByServiceAndMemberIds", colPrams);

            if (dataReader != null)
            {
                //discrepency in field order between cloud and local db
                Helpers.FileStorageIO.PLATFORM_TYPES ePlatform = uri.URIDataManager.PlatformType;
                using (dataReader)
                {
                    while (await dataReader.ReadAsync())
                    {
                        AccountToMember club = new AccountToMember();
                        club.ClubInUse = new Account();
                        club.Member    = new Member();
                        //order is Account, Member, AccountToMember
                        //set club in use
                        //Account.PKId
                        club.ClubInUse.PKId = dataReader.GetInt32(0);
                        //Account.AccountName
                        club.ClubInUse.AccountName = dataReader.GetString(1);
                        //Account.AccountDesc
                        club.ClubInUse.AccountDesc = dataReader.GetString(2);
                        //Account.AccountLongDesc
                        club.ClubInUse.AccountLongDesc = dataReader.GetString(3);
                        //Account.AccountEmail
                        club.ClubInUse.AccountEmail = dataReader.GetString(4);
                        //Account.AccountURI
                        club.ClubInUse.AccountURI = dataReader.GetString(5);
                        //Account.AccountClassId
                        club.ClubInUse.AccountClassId = dataReader.GetInt32(6);
                        //Account.GeoRegionId
                        club.ClubInUse.GeoRegionId = dataReader.GetInt32(7);
                        //not in db
                        club.ClubInUse.ClubDocFullPath = string.Empty;
                        club.ClubInUse.PrivateAuthorizationLevel
                            = AccountHelper.AUTHORIZATION_LEVELS.none;
                        club.ClubInUse.NetCost   = 0;
                        club.ClubInUse.TotalCost = 0;
                        club.ClubInUse.URIFull   = string.Empty;

                        //set member
                        club.Member.PKId = dataReader.GetInt32(8);
                        if (ePlatform == Helpers.FileStorageIO.PLATFORM_TYPES.azure)
                        {
                            //Member.MemberEmail
                            club.Member.MemberEmail = dataReader.GetString(9);
                            //Member.UserName
                            club.Member.UserName = dataReader.GetString(10);
                        }
                        else
                        {
                            //Member.UserName
                            club.Member.UserName = dataReader.GetString(9);
                            //Member.MemberEmail
                            club.Member.MemberEmail = dataReader.GetString(10);
                        }
                        club.Member.MemberJoinedDate      = dataReader.GetDateTime(11);
                        club.Member.MemberLastChangedDate = dataReader.GetDateTime(12);
                        club.Member.MemberFirstName       = dataReader.GetString(13);
                        club.Member.MemberLastName        = dataReader.GetString(14);
                        club.Member.MemberDesc            = dataReader.GetString(15);
                        club.Member.MemberOrganization    = dataReader.GetString(16);
                        club.Member.MemberAddress1        = dataReader.GetString(17);
                        club.Member.MemberAddress2        = dataReader.GetString(18);
                        club.Member.MemberCity            = dataReader.GetString(19);
                        club.Member.MemberState           = dataReader.GetString(20);
                        club.Member.MemberCountry         = dataReader.GetString(21);
                        club.Member.MemberZip             = dataReader.GetString(22);
                        club.Member.MemberPhone           = dataReader.GetString(23);
                        club.Member.MemberPhone2          = dataReader.GetString(24);
                        club.Member.MemberFax             = dataReader.GetString(25);
                        club.Member.MemberUrl             = dataReader.GetString(26);
                        club.Member.MemberClassId         = dataReader.GetInt32(27);
                        club.Member.GeoRegionId           = dataReader.GetInt32(28);
                        club.Member.AspNetUserId          = dataReader.GetString(29);

                        //set accounttomember
                        //AccountToMember.PKId
                        club.PKId          = dataReader.GetInt32(30);
                        club.IsDefaultClub = dataReader.GetBoolean(31);
                        club.MemberRole    = dataReader.GetString(32);
                        club.AccountId     = dataReader.GetInt32(33);
                        club.MemberId      = dataReader.GetInt32(34);
                        //not part of db
                        club.AuthorizationLevel = (int)AccountHelper.AUTHORIZATION_LEVELS.none;
                        club.MemberDocFullPath  = string.Empty;
                        club.URIFull            = string.Empty;
                        //the authorization level comes from this join
                        AccountToService service = new AccountToService();
                        service.PKId               = dataReader.GetInt32(35);
                        service.Name               = dataReader.GetString(36);
                        service.Amount1            = dataReader.GetInt32(37);
                        service.Status             = dataReader.GetString(38);
                        service.LastChangedDate    = dataReader.GetDateTime(39);
                        service.AuthorizationLevel = dataReader.GetInt16(40);
                        service.StartDate          = dataReader.GetDateTime(41);
                        service.EndDate            = dataReader.GetDateTime(42);
                        service.LastChangedDate    = dataReader.GetDateTime(43);
                        service.IsOwner            = dataReader.GetBoolean(44);
                        service.AccountId          = dataReader.GetInt32(45);
                        service.ServiceId          = dataReader.GetInt32(46);
                        //this is used to set ClubInUseAuthorizationLevel
                        club.ClubInUse.PrivateAuthorizationLevel
                            = AccountHelper.GetAuthorizationLevel(service.AuthorizationLevel);
                        clubs.Add(club);
                    }
                }
            }
            else
            {
                //set default objects
                AccountToMember club = new AccountToMember(true);
                //return blank member and service if not a real member or a real service
                club.ClubInUse = new Account(true);
                club.Member    = new Member(true);
                clubs.Add(club);
            }
            sqlIO.Dispose();
            return(clubs);
        }
Пример #14
0
        //note that get selections is only join table insertions
        private async Task <bool> AddService(List <ContentURI> addedURIs, List <AccountToService> addedAToSs,
                                             List <Service> addedSs)
        {
            bool   bHasSet         = true;
            string sParentNodeName = string.Empty;
            int    iParentId       = 0;

            foreach (ContentURI addedURI in addedURIs)
            {
                Helpers.GeneralHelpers.GetParentIdAndNodeName(addedURI, out iParentId, out sParentNodeName);
                if (!string.IsNullOrEmpty(addedURI.ErrorMessage))
                {
                    _dtoContentURI.ErrorMessage = DevTreks.Exceptions.DevTreksErrors.MakeStandardErrorMsg(
                        string.Empty, "INSERT_NOPARENT");
                    return(false);
                }
                if (addedURI.URINodeName == Agreement.AGREEMENT_TYPES.service.ToString())
                {
                    //addedURI.URIId == ServiceClassId == SubAppType; must be below 1000 to add a base service
                    int iMaxSubApp = (int)Helpers.GeneralHelpers.SUBAPPLICATION_TYPES.resources;
                    if (addedURI.URIId <= iMaxSubApp &&
                        _dtoContentURI.URINodeName == Agreement.AGREEMENT_TYPES.serviceaccount.ToString())
                    {
                        //base table gets inserted first
                        //2.0.0 refactor: EF no longer allows fks = 0; so changed to new NetworkId = 1
                        //new table row inserted for this purpose in table Network (see Source Code documentation)
                        int iNetworkId = 1;

                        //int iNetworkId = 0;
                        //if (_dtoContentURI.URINetwork != null)
                        //{
                        //    iNetworkId = _dtoContentURI.URINetwork.PKId;
                        //}

                        var newService = new Service
                        {
                            ServiceNum       = Helpers.GeneralHelpers.NONE,
                            ServiceName      = addedURI.URIName,
                            ServiceDesc      = Helpers.GeneralHelpers.NONE,
                            ServicePrice1    = 0,
                            ServiceUnit1     = Agreement.SERVICE_UNIT_TYPES.month.ToString(),
                            ServiceCurrency1 = Agreement.SERVICE_CURRENCY_TYPES.usdollar.ToString(),
                            //chosen after insertion
                            NetworkId = iNetworkId,
                            Network   = null,
                            //stored as the uriid
                            ServiceClassId   = addedURI.URIId,
                            ServiceClass     = null,
                            AccountToService = null,
                            BudgetSystem     = null,
                            ComponentClass   = null,
                            CostSystem       = null,
                            DevPackClass     = null,
                            InputClass       = null,
                            LinkedViewClass  = null,
                            OperationClass   = null,
                            OutcomeClass     = null,
                            OutputClass      = null,
                            ResourceClass    = null
                        };
                        _dataContext.Service.Add(newService);
                        _dataContext.Entry(newService).State = EntityState.Added;
                        addedSs.Add(newService);
                    }
                    else
                    {
                        //addedURI.URIId == joinid; need base serviceid
                        var accounttoservice = await _dataContext.AccountToService.SingleOrDefaultAsync(x => x.PKId == addedURI.URIId);

                        if (accounttoservice != null)
                        {
                            var newAccountToService = new AccountToService
                            {
                                Name               = accounttoservice.Name,
                                Amount1            = 1,
                                Status             = Agreement.SERVICE_STATUS_TYPES.current.ToString(),
                                StatusDate         = Helpers.GeneralHelpers.GetDateShortNow(),
                                AuthorizationLevel = (short)Agreement.PUBLIC_AUTHORIZATION_TYPES.public_not_authorized,
                                StartDate          = Helpers.GeneralHelpers.GetDateShortNow(),
                                EndDate            = Helpers.GeneralHelpers.GetDateShortNow(),
                                LastChangedDate    = Helpers.GeneralHelpers.GetDateShortNow(),
                                IsOwner            = false,
                                AccountId          = _dtoContentURI.URIId,
                                Account            = null,
                                ServiceId          = accounttoservice.ServiceId,
                                Service            = null,
                                AccountToIncentive = null,
                                AccountToPayment   = null
                            };
                            _dataContext.AccountToService.Add(newAccountToService);
                            _dataContext.Entry(newAccountToService).State = EntityState.Added;
                            addedAToSs.Add(newAccountToService);
                        }
                    }
                }
                else if (addedURI.URINodeName == Agreement.AGREEMENT_TYPES.incentive.ToString())
                {
                    //don't allow incentive insertions until they are needed
                }
            }
            return(bHasSet);
        }
Пример #15
0
        public async Task <bool> AddService(EditHelper.ArgumentsEdits argumentsEdits)
        {
            bool bIsAdded = false;
            //store updated service ids in lists
            List <Service>          addedSs    = new List <Service>();
            List <AccountToService> addedAToSs = new List <AccountToService>();
            bool bHasSet = await AddService(argumentsEdits.SelectionsToAdd, addedAToSs, addedSs);

            if (addedAToSs.Count > 0 || addedSs.Count > 0)
            {
                try
                {
                    //save selected subscription (atoss) and base services(addess)
                    int iNotUsed = await _dataContext.SaveChangesAsync();

                    bIsAdded = true;
                    if (addedSs.Count > 0)
                    {
                        bIsAdded = false;
                        foreach (var service in addedSs)
                        {
                            //have a good base table insertion, now can insert join
                            //only time isowner should be ever set
                            bool bIsOwner            = true;
                            var  newAccountToService = new AccountToService
                            {
                                Name               = service.ServiceName,
                                Amount1            = 1,
                                Status             = Agreement.SERVICE_STATUS_TYPES.current.ToString(),
                                StatusDate         = Helpers.GeneralHelpers.GetDateShortNow(),
                                AuthorizationLevel = (short)Agreement.PUBLIC_AUTHORIZATION_TYPES.public_not_authorized,
                                StartDate          = Helpers.GeneralHelpers.GetDateShortNow(),
                                EndDate            = Helpers.GeneralHelpers.GetDateShortNow(),
                                LastChangedDate    = Helpers.GeneralHelpers.GetDateShortNow(),
                                IsOwner            = bIsOwner,
                                AccountId          = _dtoContentURI.URIId,
                                Account            = null,
                                ServiceId          = service.PKId,
                                Service            = null,
                                AccountToIncentive = null,
                                AccountToPayment   = null
                            };
                            _dataContext.AccountToService.Add(newAccountToService);
                            _dataContext.Entry(newAccountToService).State = EntityState.Added;
                            iNotUsed = await _dataContext.SaveChangesAsync();

                            bIsAdded = true;
                        }
                    }
                    //only the edit panel needs an updated collection of services
                    if (_dtoContentURI.URIDataManager.ServerActionType
                        == Helpers.GeneralHelpers.SERVER_ACTION_TYPES.edit)
                    {
                        bHasSet = await SetURIService(_dtoContentURI, false);
                    }
                }
                catch (Exception e)
                {
                    _dtoContentURI.ErrorMessage = DevTreks.Exceptions.DevTreksErrors.MakeStandardErrorMsg(
                        e.ToString(), "ERROR_INTRO");
                }
                if (_dtoContentURI.ErrorMessage.Length > 0)
                {
                    bHasSet = await SetURIService(_dtoContentURI, false);
                }
            }
            return(bIsAdded);
        }